diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7543d93a..871057a6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,7 +1,7 @@ name: CI on: push: - branches: [master] + branches: [master, openapi-v1-trial] tags: ["*"] pull_request: jobs: @@ -12,7 +12,9 @@ jobs: fail-fast: false matrix: version: - - '1.6' + # 1.11 is the floor: OpenAPI.jl 1.0 requires it (and `[sources]` in + # Project.toml needs a Pkg that understands it). + - '1.11' - '1' # automatically expands to the latest stable 1.x release of Julia - nightly os: @@ -23,7 +25,15 @@ jobs: - uses: actions/checkout@v2 - uses: engineerd/setup-kind@v0.5.0 with: - version: "v0.11.1" + # The cluster has to serve the API surface the client was generated + # from: gen/openapi_v1/specs/SPECS_ORIGIN pins the OpenAPI documents + # to kubernetes v1.35.4, and strict response validation checks every + # reply against those schemas. v0.32.0 is the first kind release with + # a v1.35 node image (v1.35.5 differs from the spec tag by a patch + # release, which does not move the API surface). The digest is part of + # the image name on purpose — kind requires the exact published image. + version: "v0.32.0" + image: "kindest/node:v1.35.5@sha256:ce977ae6d65918d0b58a5f8b5e940429c2ce42fa3a5619ec2bbc60b949c0ac95" - name: Testing run: | kubectl cluster-info diff --git a/.gitignore b/.gitignore index 8c960ec8..3f02ca74 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ *.jl.cov *.jl.*.cov *.jl.mem +Manifest.toml diff --git a/Metrics.md b/Metrics.md index be3ce0b5..bb7bde0f 100644 --- a/Metrics.md +++ b/Metrics.md @@ -1,3 +1,29 @@ +> **Status on the `openapi-v1-trial` branch.** Neither API appears in the +> upstream Kubernetes OpenAPI documents this branch generates from — they are +> served by metrics-server and by a metrics adapter, not by the apiserver — so +> both have to be captured from a cluster that serves them +> (`gen/openapi_v1/fetch_specs.sh --from-cluster /`). +> +> - **Node and pod metrics work.** `metrics.k8s.io/v1beta1` was captured from a +> k3s v1.35.4 cluster and is shipped, so `:NodeMetrics` and `:PodMetrics` +> behave as below on any cluster running metrics-server. +> - **Custom metrics are not shipped, by decision.** `custom.metrics.k8s.io` was +> captured from a real adapter on 2026-08-15 and left out: its operations carry +> no group-version-kind and address metrics through a three-variable path, so +> the verb API cannot address them without new work, and nothing in the +> consumer repos calls the API (`OpenAPIv1ConsumerGaps.md` C5 has the +> evidence). The `list_custom_metrics`/`list_namespaced_custom_metrics` helpers +> are implemented and exported, and work as documented below against a group +> generated and registered with +> [`Kuber.register!`](README.md#adding-api-groups-kuber-does-not-ship) — which +> has to solve those two obstacles too. +> +> Two reading differences from the output shown here, which predates the +> rewrite: values come back as typed models rather than JSON, and `usage` is a +> k8s string map, so it is read with `kuber_props` and each entry is a +> `Quantity` whose string is in `.value` — +> `kuber_props(node.usage)["cpu"].value`. + Kubernetes Metrics and Custom Metrics APIs generalize consumption of metrics published by the cluster and applications running within it. ## Node and Pod Metrics diff --git a/OpenAPIv1ConsumerGaps.md b/OpenAPIv1ConsumerGaps.md new file mode 100644 index 00000000..31ab948e --- /dev/null +++ b/OpenAPIv1ConsumerGaps.md @@ -0,0 +1,1926 @@ +# Consumer compatibility and test gaps — JuliaRun and JuliaHub + +**Status: working document, opened 2026-08-13.** A survey of how the JuliaHub +production stack actually uses Kuber, measured against what the +`openapi-v1-trial` branch provides and what its test suite covers. Companion to +[`OpenAPIv1TrialResults.md`](OpenAPIv1TrialResults.md), which records what the +branch does; this one records what consumers need from it. + +**This is meant to be iterated on.** The `C…` and `G…` identifiers are stable +references — cite them in review, and tick the boxes as items close. Add new +findings with the next free number rather than renumbering. + +Two views of the same work. Parts 1 and 2 are organised by *finding*, and hold +the reasoning. The [consumer checklist](#consumer-checklist) is organised by +*repository*, and is the one to work through when doing the port: its boxes are +per call site, and a finding's own box closes when all of its sites are ticked. + +## Scope of the survey + +| Consumer | Kuber pin surveyed | +|---|---| +| `JuliaRun.jl` (+ `JuliaHubK8sApi.jl` 0.2.3) | 0.7.9 | +| JuliaHub monorepo — `services/JobLoops` | 0.7.11 | +| JuliaHub monorepo — `packages/K8sReflector`, `packages/JuliaRunPool`, `packages/AccessControl`, `services/BillingService` | unpinned / transitive | + +27 Kuber-using files in the monorepo, plus all of `JuliaRun/src/kubernetes/` and +`JuliaRun/src/metrics/`. + +## Headline + +**The current tests do not cover consumer usage, and coverage is the second-order +problem.** The consumers do not use Kuber's generated layer at all: they use +Kuber's *verb* layer over a JuliaHub-specific generated layer +(`JuliaHubK8sApi`), plugged in through a `KuberContext(apimodule)` mechanism this +branch removed. Several APIs they call no longer exist, so no test could cover +them. Part 1 is that list; Part 2 is the genuine coverage gaps. + +*Update, 2026-08-14:* the plug point is back, in a different shape — +[C1a](#c1a-the-mechanism--cheap-because-the-architecture-is-already-plugin-shaped) +is done. `Kuber.register!` merges an out-of-tree generated layer into the +registry from the registering package's `__init__`. + +*Update, 2026-08-15:* and the content half of C1 has gone away rather than been +done. Kuber's shipped layer turned out to be a superset of what the consumers +reach, so `JuliaHubK8sApi` is **dropped, not regenerated** — see C1b. That leaves +`Kuber.register!` with no in-house consumer at all, which is the right mechanism +to have and now an untested-in-anger one: the first real registration will be +whatever CRD or aggregated group someone needs next. + +One thing that raises the stakes: **JuliaHub's own tests mock Kuber out** — +`services/JobLoops/src/hot_standby.jl` has 15 `@mock Kuber.…` call sites. The +consumer test suites will not catch any of this. Kuber's own suite is the only +real coverage these call paths get. + +--- + +## Part 1 — Hard incompatibilities + +Porting work, not test gaps. No test can cover an API that no longer exists. + +### C1. The pluggable generated layer is gone + +- [x] Add `Kuber.register!` (registry merge) — the mechanism. **Done**: + `src/register.jl`, covered by `test/register.jl` (57 assertions, offline). +- [ ] ~~Regenerate `JuliaHubK8sApi` through `gen/openapi_v1/` with the two or + three group versions that are actually used — the content.~~ **Superseded + 2026-08-15: drop the package instead and use Kuber directly.** Once + `metrics.k8s.io` shipped in Kuber, the only group version it still added + was `custom.metrics.k8s.io`, which nothing calls. See C1b. + +`JuliaHubK8sApi` is not an extension of Kuber's generated code; it is a **drop-in +replacement** for it. Its `src/` contains exactly the three things this branch +deleted: `api/Kubernetes.jl` (models + `*Api` operation modules), +`api_typemap.jl`, `api_versions.jl`. + +JuliaRun consumes it that way: + +- `JuliaRun/src/kubernetes/types.jl:8-12` — `KuberContext(K8sApi; long_polling_timeout=…, timeout=…)` +- `JuliaRun/src/metrics/kubernetesmetrics.jl:58-62` — same +- `JuliaRun/src/kubernetes/kubernetes.jl:52` and `src/metrics/kubernetesmetrics.jl:13` — `const K8sApi = JuliaHubK8sApi` + +On `master`, `KuberContext(apimodule::Module=ApiImpl; httplib, kwargs...)` +(`src/helpers.jl:107`). On this branch the constructor is `KuberContext(; kwargs...)` +(`src/helpers.jl:86`) — no apimodule parameter. + +**This is two problems with very different costs, and an earlier revision of this +document conflated them.** + +#### C1a. The mechanism — cheap, because the architecture is already plugin-shaped + +Not a redesign. Three properties make an external module admissible almost as-is: + +- **`_new_client` is already duck-typed on the module.** `src/helpers.jl:138` is + just `mod.Client(ctx.server; …)`. Nothing in `src/` references `_SPEC`. Any + OpenAPI.jl 1.0 generated module qualifies. +- **The verb layer binds the tables, not their contents** — `using .ApiImpl: + GROUP_MODULES, MODULE_GVS, KIND_TYPES, OPS, OP_PARAMS`. Those are `const` + *bindings* to *mutable* `Dict`s, so a `merge!` is visible immediately with no + recompilation. +- **The keys make merging conflict-free.** `OPS` is + `(module, verb, kind, scope)`, `KIND_TYPES` is `(apiVersion, kind)`, + `MODULE_GVS` is by module. Two packages collide only if they claim the same + group-version — which should be an error anyway. + +**Built as `src/register.jl`.** `Kuber.register!(source::Module)` reads the six +tables off a *registry module* — the shape `emit_registry.jl` already emits — and +merges them; a keyword form takes the tables directly, for tests and for +hand-built entries. `Kuber.unregister!` removes a module and everything it +brought, and refuses to touch the group modules Kuber ships. Four decisions worth +recording: + +- **Everything is validated before anything is merged**, against the same + invariants `test/registry.jl` asserts over the merged result — mutual inverse, + `keys(OPS) == keys(OP_PARAMS)`, types and operations defined in the module that + claims them, known verbs and scopes — plus `isdefined(mod, :Client)`, the one + name Kuber calls on a group module. A rejected registration leaves the tables + untouched, so a malformed layer cannot half-load. +- **A group version already served by a different module is an error**, not a + silent override; `unregister!` first if replacing one is really the intent. + Re-registering identical content is a no-op. +- **Registration order does not decide which module serves a kind.** + `build_model_api_map` is still first-wins over core-then-alphabetical group + order, so a kind name a shipped group already declares stays with the shipped + group; `apiversion=` is the escape hatch. Asserted in `test/register.jl`. +- **No registry-generation counter.** A context that already ran discovery does + not see newly registered kinds in `ctx.modelapi` until it discovers again — + but both consumers load their layer with a top-level `using` + (`JuliaRun/src/kubernetes/kubernetes.jl:18`, + `JobLoops/src/k8s_job_pod_monitoring.jl:5`), so `__init__` runs before any + context exists. Invalidating contexts automatically would have meant changing + the `ctx.initialized` guard that `test/simpleapi.jl:64` and + `test/watch_recovery.jl:94` set by hand to fake discovery. Revisit only if a + consumer starts loading its layer lazily. + +**Constraint for the registering package:** `register!` must run in its +`__init__`, not at top level — mutations to another module's state during +precompilation do not persist. Registered kinds are therefore absent from Kuber's +precompile image and pay first-call compilation, which matters given TTFX is +already ~15 s. + +**Do not restore `KuberContext(apimodule)`.** It saves no regeneration (an external +module still has to supply tables in the new shape), it re-introduces the +per-context table scoping that keying `OPS` by module deliberately removed, and it +makes "two modules serve `apps/v1`" ambiguous instead of an error. Registration +being process-global is fine: `ctx.apis` and `ctx.modelapi` are still built +per-context at discovery from `KIND_TYPES`, so two contexts on different clusters +each resolve their own subset. The tables are global; resolution is not. + +#### C1b. The content — small, once scoped to what is actually used + +> **Decision, 2026-08-15: do not regenerate it — remove it.** This section +> narrowed the job from 26 group versions to three, and everything that happened +> after took it to zero. `metrics.k8s.io/v1beta1` now ships in Kuber; the audit +> found no CRD group used at all; and `custom.metrics.k8s.io` has no live caller, +> so C5 declined to ship it. Kuber's shipped layer is therefore a **superset of +> what the consumers actually reach**, and the package has nothing left to +> contribute. The reasoning below still stands as the argument for *why* it +> shrank to nothing; the work is in +> [the consumer checklist](#5-remove-the-juliahubk8sapi-dependency--last-everywhere-at-once). + +`JuliaHubK8sApi` ships 43 group versions and this branch's 17 are a strict subset, +so it adds 26. Per the [usage audit](#appendix--juliahubk8sapi-group-version-usage-audit), +**two are actually reachable through Kuber, possibly three, and no CRD group is +used at all.** So this was "regenerate two or three well-behaved aggregated APIs", +not "regenerate 26 including operator CRDs" — and then even those three went +away. + +**Capture-from-cluster is the mechanism, it works, and it is now built.** +`fetch_specs.sh --from-cluster /` reads +`/openapi/v3/apis//` and records provenance — cluster version, +context, date, checksums — in `SPECS_CAPTURED`, a separate file from the tag +mode's `SPECS_ORIGIN` so neither clobbers the other. A captured document is only +as reproducible as the cluster it came from, which is why it says so. + +**`metrics.k8s.io/v1beta1` is captured and shipped** (2026-08-14, from k3s +v1.35.4). It went through the chain without a new patch rule — the existing +nullable rules covered it — strict generation passed first time, and it is +verified live: `test_metrics` in `test/runtests.jl` reads node metrics, pod +metrics in one namespace and across all of them, and single objects of each, +under strict response validation. + +**That corrects this document's earlier "the generated output belongs in +`JuliaHubK8sApi`, not in Kuber".** It is right for deployment-specific groups and +wrong for `metrics.k8s.io`: the 0.2.x line shipped it *in Kuber* — master's +`SupportedAPIVersions.md` lists `metrics_v1beta1` and `api_typemap.jl` has the +`MetricsV1beta1` aliases — `Metrics.md` is a Kuber document, and metrics-server +is on nearly every cluster. Dropping it was a regression for every Kuber user, +not just JuliaHub. The line to draw is *could any user of this API plausibly have +this group*: metrics-server yes, an operator's CRDs no. + +**And the same argument reaches `custom.metrics.k8s.io`** — this document said +otherwise until 2026-08-15, and the correction is [C5](#c5-custom-metrics-captured-evaluated-not-shipped). +The helpers that call it (`list_custom_metrics`, `list_namespaced_custom_metrics`) +are exported from Kuber and documented at length in `Metrics.md`; 0.2.x shipped +the group in Kuber too (`SupportedAPIVersions.md` listed `custom_metrics_v1beta1`, +`api_typemap.jl` had the `CustomMetricsV1beta1` aliases); and the *schema* is +adapter-independent — it is boilerplate from upstream `custom-metrics-apiserver`, +and what varies per adapter is the metric names, which are path parameters rather +than types. Shipping the helpers here and the group they call in another package +is the incoherence this section just corrected for `metrics.k8s.io`. + +**The 2026-08-15 capture confirmed that reasoning and still ended in "do not +ship"** — on cost, not on where the group belongs. The schemas are the predicted +boilerplate; the *operations* carry no GVK and address metrics through a +three-variable path, which neither the registry emitter nor the verb layer can +carry today, and nothing in either repo actually calls the API. C5 has the +evidence. So the boundary rule stands as written; this group simply is not worth +what it costs to cross it yet. + +So what is left for `JuliaHubK8sApi` is **nothing**: no CRD group is used through +Kuber, the audit found none needed, and the last aggregated group it still +provided has no caller. A package that contributes no group version is a +dependency, not a layer — hence the decision above to remove it. + +Two things C1a left for this step to prove, one now settled: + +- **`_new_client`'s duck-typing is exercised** — but by the shipped metrics + module, not by a registered one. The live metrics tests build a client for a + group module through the ordinary `client_for` path, which is the same code an + out-of-tree module goes through; what is still untested is that path with a + module Kuber does not ship. `test/register.jl` cannot do it: `_new_client` calls + `Runtime.codec!`, which needs a real compiled `Spec`, so the proof needs a + genuinely generated external module. +- **`emit_registry.jl` emits a file that assumes it lands inside `ApiImpl`, + after the group modules** — it refers to them by bare name. An external package + that mirrors that layout (group modules included first, registry after, all in + one module) works as-is; one that structures itself differently will need the + emitter to qualify the names. + +#### C1c. What the port costs JuliaRun + +Written when the plan was to regenerate the package, and kept because the +measurement is what argued the package away. **`Typedefs` is a generated tree of +plain aliases** (`JuliaHubK8sApi/src/api_typemap.jl:1252-1260` is `const Secret = +Kubernetes.IoK8sApiCoreV1Secret` and so on), so re-emitting it over the new type +names would have been mechanical and JuliaRun's ~28 `K8sApi.Typedefs.*` +references would have survived verbatim. The exceptions: + +- `Typedefs.CoreV1.WatchEvent`, `Typedefs.MetaV1.WatchEvent` and + `Typedefs.EventsV1.Status` cannot work. The aliases can exist, but Kuber now + yields `KuberEvent` and `Status` is per-module, so nothing will ever `isa` them. + Sites: `JuliaRun/src/kubernetes/clustermgmt.jl:513`, `src/kubernetes/api.jl:1572`, + `src/kubernetes/api.jl:1689`. +- `KuberContext(K8sApi; …)` → `KuberContext()` (see C1a) plus C6's kwargs. +- C4 and C7 are untouched by any of this. + +**Dropping the package instead does not cost much more, and a hand-written alias +block to avoid the difference was considered and rejected.** The 28 references +are not 28 independent sites: they cluster into four `isa` chains over a watch +stream, like `clustermgmt.jl:511-516`, where + +```julia +if isa(event, Typedefs.CoreV1.NodeList) # would survive an alias +elseif isa(event, Typedefs.CoreV1.WatchEvent) # cannot: events are KuberEvent + node = kuber_obj(cm.ctx, event.object) # no longer needed either + nodes = isa(node, Typedefs.CoreV1.Node) ? [node] : [] +elseif isa(event, Typedefs.EventsV1.Status) # cannot: Status is per-module +``` + +Three of those four chains contain a branch that has to be rewritten whatever +happens, so "the call sites stay as they are" was never true for the code that +matters — an alias would have preserved two branches in five and left each block +half-migrated. And for `isa` an alias is the wrong construct anyway: a +`const Pod = K8sV1.IoK8sApiCoreV1Pod` pins the group version at the call site, +reintroducing by hand the coupling the registry exists to remove. +`kind_to_type(ctx, :Pod)` resolves through the server's preferred version. + +So the references split by what they *do*, not by where the type came from: + +| Use | Sites | Becomes | +|---|---|---| +| `isa` over a watch stream | `clustermgmt.jl:511-516`, `api.jl:1570-1576`, `api.jl:1687-1692` | `KuberEvent`, `kuber_kind(x) == "Status"`, `kind_to_type(ctx, :Node)`; the `kuber_obj(ctx, event.object)` line goes, `event.object` is already typed | +| construction | `api.jl:220-248` (Secret, ObjectMeta), `api.jl:264` (Status) | a concrete type — `kind_to_type` needs a context, so name the type directly | +| `isa` on a plain model | `api.jl:1841-1843`, `clustermgmt.jl:20` (`Quantity`) | either form; a direct reference is one indirection fewer | + +That leaves roughly eight sites wanting a concrete type rather than 28 — too few +to justify a `Typedefs`-shaped namespace that mimics a generated package which no +longer exists. + +#### C1d. The dynamic alternative, for later + +A `register_crd!(gv, kind, plural, scope)` that synthesises operations from the +standard REST shape and treats bodies and responses as `Dict` would let a CRD be +addressed with no capture, no generation and no release. It could even be +automatic: discovery already returns everything needed — `/apis/helm.cattle.io/v1` +gives `name: "helmcharts"`, `kind: "HelmChart"`, `namespaced: true`, `verbs`, and +subresources (`helmcharts/status`). + +It is **not** a runtime substitute for C1: no generated models means no `isa`, no +typed construction and no field dispatch, so it cannot carry JuliaRun's reading +code — though it fits JobLoops, which already builds `Dict{String,Any}` specs. And +those kinds would bypass response validation, which needs an explicit decision: +not the same as `validate_responses=false` (there is no spec to ignore), but +adjacent to a locked constraint. + +Given that the audit found no CRD group in use, this is future-proofing rather +than a prerequisite — worth deferring until a CRD actually needs addressing. + +### C2. `OpenAPI.Clients` does not exist in OpenAPI.jl 1.0 + +- [x] Export a supported replacement (see [G15](#g15-exception-classification-for-consumers)). + **Done 2026-08-14**: `Kuber.is_retryable`. +- [ ] Port the call sites. + +Consumers import it directly: + +- `packages/K8sReflector/src/K8sReflector.jl:4` — `using OpenAPI.Clients: is_longpoll_timeout, is_request_interrupted` +- `services/BillingService/src/billing/main.jl:62` — `httplib=OpenAPI.Clients.HTTPLib.HTTP` +- `packages/AccessControl/src/AccessControl.jl:77` — `kwargs[:httplib] = OpenAPI.Clients.HTTPLib.HTTP` +- `JuliaRun/src/kubernetes/api.jl:1040, 1053, 1065, 1529` and + `JuliaRun/src/kubernetes/clustermgmt.jl:114-115` — `isa(err, OpenAPI.Clients.ApiException)`, + and one `ex.resp.data` read. *(Found 2026-08-14; not in the original survey.)* + +Load failures, not behaviour changes. What each one becomes: + +| Gone | Successor | +|---|---| +| `is_request_interrupted` | **`Kuber.is_retryable(e)`** — same question, stated over `HTTP.HTTPError` as an exclusion list. Unwraps `TaskFailedException`/`CompositeException`, so it works on what `watch` throws | +| `is_longpoll_timeout` | none, and none is needed: watches carry no overall deadline here, so a watch never ends on one. It ends when the consumer closes the stream, which is not an exception | +| `OpenAPI.Clients.ApiException` | `Kuber.KuberException` — every generated call goes through `_call`, which rewraps `Runtime.ApiError`. `ex.resp.data` becomes `ex.message` (the body verbatim) or `ex.response` | +| `httplib=` | nothing; there is one backend | +| `getpropertyat` / `haspropertyat` | **`Kuber.getpropertyat` / `Kuber.haspropertyat`** — same walk, `ABSENT`-aware. Unexported, so qualify them. 49 call sites in JuliaRun become a changed import | + +The `is_request_interrupted(ex) && isopen(rf.stream_handle[])` idiom at +`K8sReflector.jl:241-242` has no direct translation, and does not need one: a +consumer-initiated stop no longer surfaces as an interruption to be told apart +from a transient one. Closing the stream makes `watch` *return*, not throw. + +One thing the port will surface, unrelated to Kuber: `api.jl:1053` and `1065` +read `OpenAPI.Clients .. ApiException`, with spaces. That parses as a call to +`..`, which nothing defines — so those two `catch` blocks would `MethodError` +over the original error if they were ever reached. + +**`getpropertyat`/`haspropertyat` are the big one, and were missed until the G12 +audit.** `JuliaRun/src/kubernetes/kubernetes.jl:21` does +`import OpenAPI.Clients: getpropertyat, haspropertyat`, and there are **49 uses** +across `clustermgmt.jl`, `api.jl` and `kubernetes.jl`. Confirmed absent from the +pinned 1.0 commit — they existed only in the 0.x client. + +They are not hard to replace, but the semantics must change with them, which is +the part that makes this more than a rename. On 0.x an unset field was `nothing`, +so `haspropertyat(pod, :status, :phase)` answered a real question. On 1.0 every +field exists and an unset one is `ABSENT`, so a naive `hasproperty` walk answers +`true` unconditionally — the same trap [G12](#g12-resource-limits-are-an-open-struct) +found in `container_resource`. A faithful replacement has to treat both `ABSENT` +and `nothing` as absent, which is exactly what `Kuber._field(x) === nothing` +does. + +**Added 2026-08-15 as `Kuber.getpropertyat` / `Kuber.haspropertyat`**, kept +**unexported** — they are a shim for consumers porting off 0.2.x, not a shape +this API wants to encourage, so a call site has to say `Kuber.` and stays easy +to grep for later. Covered by `test/helpers.jl`. + +For JuliaRun this turns 49 rewrites into a changed import: + +```julia +import OpenAPI.Clients: getpropertyat, haspropertyat # before +import Kuber: getpropertyat, haspropertyat # after +``` + +Two behaviours differ from 0.x, and both are deliberate: + +- **`ABSENT` counts as absent**, which is the entire reason these exist. A + handwritten `hasproperty` walk answers `true` for every field on 1.0. +- **A path element may name an open-struct entry**, so + `getpropertyat(node, :metadata, :labels, "role")` reads a label directly. + That covers the `get(nodelabels, "role", "")` sites in `clustermgmt.jl:203-204` + as well, which would otherwise each need a `kuber_props` call. + +**They do not fold case, and that matters at these call sites.** The path is the +*generated* field name, which lowercases the JSON one — `:nodename`, not +`:nodeName`. JuliaRun's existing calls include `:loadBalancer`, `:nodeName` and +`:backoffLimit`, so those are [C4](#c4-camelcase--lowercase-field-names) fixes +that still have to be made by hand. Folding case would have hidden them, and +would have made a typo succeed whenever it happened to lowercase-match. + +### C3. `ctx.apimodule` reach-through + +- [ ] Port `K8sReflector` off generated `WatchEvent`/`Status` types. + +`packages/K8sReflector/src/K8sReflector.jl:52-53` reads +`c.apimodule.Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent` and +`…MetaV1Status` to get the types it later dispatches on. This branch has no +`apimodule` field; watch events are `KuberEvent` (not a generated type), and +`Status` exists once per group module, so there is no single type to compare +against — `kuber_kind` is the intended test. + +### C4. camelCase → lowercase field names + +- [ ] Sweep consumer model-field access. + +- `packages/K8sReflector/src/K8sReflector.jl:12` — `i.metadata.resourceVersion` → `resourceversion` +- `services/JobLoops` — `.containerStatuses` (5 sites), `.restartCount`, `.nodeName` + +These surface as `type has no field` at runtime, on the paths that matter most. + +The rule is **lowercase the JSON name**, not snake_case it: the field is +`desirednumberscheduled`, never `desired_number_scheduled`. Worth stating because +snake_case is what an OpenAPI-generated Julia model usually looks like, so the +wrong guess is the natural one. Status fields are where this bites hardest — +they are the longest names (`observedgeneration`, +`persistentvolumereclaimpolicy`, `currentnumberscheduled`) and the ones a +consumer reads in a poll loop, so a typo shows up as a runtime error the first +time that loop runs rather than at load. Writing G6's testset needed the +translation on nine such fields. + +### C5. Custom metrics: captured, evaluated, not shipped + + + +- [x] Generate `metrics.k8s.io/v1beta1`. **Done 2026-08-14** — captured and + shipped *in Kuber* rather than in `JuliaHubK8sApi`; see C1b for why that + moved, and `test_metrics` in `test/runtests.jl` for the live coverage. +- [x] Reimplement `list_custom_metrics` / `list_namespaced_custom_metrics` over the + registry — on `master` they are one-liners delegating to + `list(ctx, :MetricValue, "//")`. **Done**: they + are those one-liners again, and `list(ctx, O, name)` exists again to carry + them. +- [x] Capture `custom.metrics.k8s.io/v1beta1` from a cluster running an adapter. + **Done 2026-08-15** — `prometheus-adapter` v0.12.0 on the local k3s, no + Prometheus behind it. The document is kept as evidence in + `gen/openapi_v1/reference-captures/`, deliberately *not* in `specs/`. +- [x] Check whether `custom.metrics.k8s.io/v1beta2` is also needed. **Answered: + no** — see "the gate command's trap" below. +- [ ] ~~Ship the group.~~ **Decided against on 2026-08-15**, on the evidence + below. Not a deferral for want of infrastructure: the capture exists and + the answer it gave was no. + +#### Nothing calls this API + +The audit that opened this section counted *references*, which is not the same +thing. Counting callers instead: + +- `JuliaRun/src/metrics/kubernetesmetrics.jl` is the only code in either repo + that touches `custom.metrics.k8s.io` **or** `metrics.k8s.io`. Nothing in + JuliaRun constructs a `KubernetesMetricsCtx`; the one construction is + `JuliaRun/test/test_metrics.jl:106`, and `test/runtests.jl` never includes that + file — it is a standalone probe with a top-level call at its line 176. +- Org-wide code search puts `KubernetesMetricsCtx` in JuliaRun and nowhere else. + The monorepo has no `NodeMetrics`, `MetricValue`, `list_custom_metrics`, + `MetricsV1beta1` or `metrics.k8s.io` in any Julia file. + +`metrics.k8s.io` stays regardless — it is already shipped and live-tested, +metrics-server is near-universal, and 0.2.x had it, so dropping it would be a +regression for Kuber users generally. Custom metrics is the one where the cost +had to be justified by a caller, and there is none. + +#### The capture confirmed the schemas and refuted the operations + +The prediction was that the document is adapter-independent boilerplate. **On the +schemas that is exactly right** — `components.schemas` holds `MetricValue`, +`MetricValueList`, and shared meta/core types (`ObjectReference`, `Quantity`, +`LabelSelector`, `ListMeta`, `Time`, `APIResource(List)`). No metric name appears +anywhere in the schema; metric names are discovered dynamically, which is why the +resource list came back empty with no Prometheus behind the adapter while the +document was complete. The `allOf`-wrapped `$ref`s that patch rule §7 collapses +are there too, so the existing rules would have applied unchanged. + +**The operations are another matter, and they are what decides the cost:** + +- **No operation carries `x-kubernetes-group-version-kind`, or + `x-kubernetes-action`.** Both are what `emit_registry.jl`'s `ops()` runs on: its + first pass needs the GVK *and* a known action to learn the kind behind a + resource (`emit_registry.jl:245-248`), and its second pass drops every + operation whose resource it did not learn (`:256`) and every operation without + an action verb (`:261-262`). With neither annotation present, `OPS` gets + *nothing* for this group while `KIND_TYPES` populates normally — the schemas do + carry GVK. That end state is worse than not shipping: + `kind_to_type(ctx, :MetricValue)` would work while `list(ctx, :MetricValue, …)` + could not resolve. Compare the `metrics.k8s.io` capture, where every operation + carries both. (Read off the captured document and the emitter's source; the + chain was not run on it, since there is nothing to generate.) +- **Metrics are addressed through a three-variable path.** The real paths are + `/{resource}/{name}/{subresource}` and its namespaced twin, plus + `/namespaces/{namespace}/metrics/{name}`. So the operations take `resource`, + `name` and `subresource` as *separate* path parameters — `_positional` accepts + one, and `emit_registry.jl`'s plural→kind pass keys on a literal + `…/{plural}/{name}` segment, which a variable resource segment cannot supply. + +Shipping therefore needs a new patch rule to inject operation GVKs, emitter +support for a variable resource segment, and verb-layer work to split one +composite name back across three path parameters — none of it coverable in CI, +since the group is absent from any cluster without an adapter. Against zero +callers, that is the wrong trade. + +#### Correction: `compositemetricname` was never real + +This document and `src/simpleapi.jl` both said the path parameter is called +`compositemetricname`, and that there is only ever one of them. That came from +`master`'s hand-spliced Swagger fragment, which collapsed +`{resource}/{name}/{subresource}` into a single parameter — a fiction that +produced the right URL, since joining the three with `/` is exactly the composite +string `list(ctx, :MetricValue, "pods/*/http_requests")` passes. A served +document does not do that. Both places are corrected; the `_positional` +relaxation stays, because accepting a path parameter under some other name is +still right for captured groups generally — it simply is not what this group +needed. + +#### The gate command's trap + +Before capturing anything, one command says whether a cluster can produce a +document at all — `fetch_specs.sh --from-cluster` does nothing but +`kubectl get --raw /openapi/v3/apis//`: + +```sh +kubectl get --raw /openapi/v3 | jq -r '.paths | keys[]' | grep custom.metrics +``` + +On the adapter above this printed `v1beta1` **and** `v1beta2` — and `v1beta2` is +not reachable: no `APIService` registers it, `/apis/custom.metrics.k8s.io/v1beta2` +returns `NotFound`, and discovery advertises `v1beta1` alone as both available and +preferred. **An entry in `/openapi/v3` means the aggregated server compiled that +version in, not that the cluster serves it.** Check `kubectl get apiservices` and +`/apis` before trusting a version, whichever group is being captured. + +That also answers the `v1beta2` checkbox: `:MetricValue` resolves through server +preference, and the server prefers — and offers — only `v1beta1`. JuliaRun's own +deploy manifests agree, registering `v1beta1` only. + +#### What is still available to anyone who needs it + +Everything on Kuber's side is done and stays: + +- **`list(ctx, O, name)` is back.** The trial's `list` took no name, so master's + one-liners had nowhere to put the composite metric name. +- **`list_custom_metrics` / `list_namespaced_custom_metrics` are implemented and + exported**, as the same one-liners `master` had. +- **`Kuber.register!`** is the supported route for the group itself: capture it + from a cluster that serves it, generate, register. The reference capture's + README has the exact commands, and the two obstacles above are what such a + registration has to solve — they are not specific to shipping it in Kuber. + +`JuliaRun/src/metrics/kubernetesmetrics.jl` is the code this would serve: + +- lines 213-228 — `list_namespaced_custom_metrics` / `list_custom_metrics` (5 call sites) +- lines 186-188 — `Typedefs.CustomMetricsV1beta1.MetricValueList` / `MetricValue` +- lines 87, 130 — node and pod metrics via `metrics.k8s.io` +- `:NodeMetrics`, `:PodMetrics` kind symbols (2 each) + +Node and pod metrics (lines 87, 130, and both kind symbols) work today. The +`custom.metrics` call sites do not, and by the finding above nothing calls them. + +### C6. `KuberContext` timeout kwargs + +- [ ] Port `long_polling_timeout` / `timeout` to `request_options`. + +Both call sites are the ones in C1. `set_timeout` now sets `request_timeout`; +`set_request_options` passes the rest through. Watches deliberately take no +overall deadline — bound them with `timeout_seconds`. + +### C8. JSON patches did not encode at all + + +- [x] Declare the json-patch body as an array, and carry a body type per media + type. **Done 2026-08-14**: `patch_k8s_spec.jq` §6, `OP_BODIES` reshaped, + `update!` selects on `content_type`. + +Kubernetes' OpenAPI document declares **one** request schema — `meta.v1.Patch`, +`type: object` — for all five patch media types. That is untrue of +`application/json-patch+json`, whose body is an array of RFC 6902 operations. The +generated `Patch` model can only hold an object, so: + +```julia +julia> Runtime._decode(Patch, [Dict("op" => "replace", "path" => "/spec/replicas", "value" => 2)], false) +ERROR: DecodeError: expected an object while decoding …Patch, got Vector{Dict{String, Any}} +``` + +Every json-patch caller in the stack was therefore broken, which is **all** of +them — `julia_parallel_scale` (every worker scale-up and scale-down), +`taint_update_patch`, `julia_update_job`, and `hot_standby.jl`'s deployment +scaling. Only `master`'s merge-patch callers (`set_node_cordon`, +`set_node_label`, the Secret patch) would have worked. + +The fix is a patch rule, per the branch's standing rule that a document which +lies gets one: the json-patch content schema becomes +`{"type": "array", "items": {"type": "object"}}`, declared once as a component +(`meta.v1.JSONPatch`) and referenced. Inlining it per operation makes the +generator emit one item type per patch operation — 132 in `apps/v1` alone, ++27 KiB — where the shared component emits one, +3.4 KiB. Items stay untyped +objects: `move`/`copy` carry `from`, `remove` carries no `value`, so anything +stricter would reject valid patches under strict request validation. + +`OP_BODIES` consequently maps **media type → body type** instead of carrying one +type and a list of media types, since a PATCH now genuinely has two body types. +That is a change to the registration contract published in +[C1a](#c1a-the-mechanism--cheap-because-the-architecture-is-already-plugin-shaped), +so the docstring, the fixture in `test/register.jl` and the validation in +`_check_registration` moved with it. + +`update!` also normalizes two other shapes the 0.2.x client accepted, through +`_patch_payload`: a patch given as **JSON text**, and a patch given as a +**generated model** — `JuliaRun/src/kubernetes/api.jl:252` patches a Secret with +a whole desired `Secret`. A model cannot be decoded into the open `Patch` struct +directly (it wants an object, not a struct), so it is encoded to its JSON object +first. That one was found by the live test, not by reading: it is the shape a +reviewer is least likely to think of. One consequence worth stating: a malformed json-patch — an *object* +under `application/json-patch+json`, which is what +`JobLoops/src/networkpolicy.jl:142` sends (see [C9](#c9-a-live-defect-in-jobloops-found-in-passing)) — now +fails inside Kuber as a `DecodeError` rather than reaching the server for a 422. +`is_retryable` says a `DecodeError` is not retryable, which is the right answer +for a malformed body: `@retry_on_error` around that call will stop retrying it. + +### C9. A live defect in JobLoops, found in passing + + +- [ ] Fix `networkpolicy.jl:142` in the monorepo — not a Kuber change. + +`services/JobLoops/src/networkpolicy.jl:141-143` updates a network policy with + +```julia +update!(ctx.ctx, :NetworkPolicy, name, json(POLICIES[name]), "application/json-patch+json") +``` + +`POLICIES[name]` is a whole NetworkPolicy **object** (`networkpolicy.jl:96-98`), +so this sends an object body under a media type whose body must be an array of +operations. It cannot ever have worked as intended: a real apiserver answers 422. +The likely intent is `application/merge-patch+json`, or +`application/strategic-merge-patch+json` to match how the policies are created. +Worth checking whether the update path is simply never taken — `needs_update` +only fires when the `version` label differs. + +### C7. `ABSENT` audit — smaller than expected, but not zero + +- [ ] Audit the read side: `K8sReflector`, `JuliaRun/src/kubernetes/{clustermgmt,api}.jl`. + +Already on the results-doc checklist, and narrower than that checklist implies. +Traced sites: the `!== nothing` hits in `services/JobLoops/src/provisioner.jl` and +`src/deployment_queue.jl` are on JuliaHub's own types (`JobToSpawn`, +`deployment_queue.jl:171`) and on plain `Dict{String,Any}` job specs — **not** on +Kuber models. JobLoops builds k8s objects as dicts and hands them to +`put!(ctx, kind, dict)`, which is inherently ABSENT-proof. + +So there are no confirmed model-field `=== nothing` sites in the monorepo, and the +exposure is concentrated on the *read* side, where model fields are accessed +directly. + +--- + +### C10. `OpenAPI` itself, not just `OpenAPI.Clients` + +*Found 2026-08-15, while checking whether JuliaRun could be ported from the +documents alone. It could not: C2 surveyed `OpenAPI.Clients` and missed two uses +of the `OpenAPI` module proper.* + +- [ ] Replace `OpenAPI.APIModel` at its 8 dispatch sites in JuliaRun. +- [ ] Replace `OpenAPI.to_json` at `JuliaRun/src/kubernetes/provisioning.jl:68`. +- [ ] Decide whether Kuber should export a supported way to do the second one. + +**`OpenAPI.APIModel` is gone, and nothing replaces it.** Generated models on 1.0 +have no shared abstract supertype at all — `supertype(IoK8sApiCoreV1Pod)` is +`Any`. JuliaRun uses it as a dispatch constraint at eight sites: + +- `src/kubernetes/kubernetes.jl:20` — `import OpenAPI: APIModel` +- `src/kubernetes/types.jl:33` — `spec::Union{Nothing, OpenAPI.APIModel}` +- `src/kubernetes/clustermgmt.jl:124` — `KuberNodeState(status::T, nodespec) where {T <: OpenAPI.APIModel}` +- `src/kubernetes/api.jl:9, 16, 33, 151, 1767` — `put!`/`update!`/`namespace!`/`_get_parallel_status` + +Every one of them is separating "a model" from "a `Symbol` or a `Dict`", which is +what the verb API dispatches on anyway. So the fix is usually to drop the +constraint and let the existing `Symbol`/`AbstractDict` methods take precedence, +rather than to look for a new supertype. `types.jl:33`'s field type is the +exception — a struct field needs a concrete-enough type, and `Any` is the honest +one there. + +**`OpenAPI.to_json` is gone, and the obvious replacement is silently wrong.** + +```julia +push!(objects, :Secret => _parse_json(OpenAPI.to_json(secret))) # provisioning.jl:68 +``` + +`JSON.json(model)` looks like the successor and is not: it serialises the Julia +struct, so field names come out **lowercase** (`"apiversion"`) and absent fields +come out as the literal string `"ABSENT"`. A cluster rejects that, and nothing +about it looks wrong until it is on the wire. + +``` +JSON.json(pod) -> {"apiversion":"v1","kind":"Pod","metadata":{"annotations":"ABSENT",… +Runtime._encode(pod) -> {"apiVersion":"v1","kind":"Pod","metadata":{"labels":… +``` + +`Kuber.Runtime._encode(model)` is what produces the wire shape — correct +camelCase, absent fields omitted — and it returns a `JSON.Object`, so the +`_parse_json(...)` round-trip at that call site collapses into it. + +**But `_encode` is private**, and a consumer serialising a model to JSON is an +ordinary thing to want. That is the third box: either bless a `Kuber.kuber_json` +(or similar) wrapper, or accept that consumers reach for an underscore. Reaching +for the underscore is at least *correct*, which `JSON.json` is not — but it is a +poor thing to have to discover, and this document only discovered it by looking. + +## Part 2 — Test gaps + +Things this branch *does* support (or has deliberately changed the contract of) +where consumer usage is not exercised by any of the 3824 offline or ~303 live +assertions. + +### Watch contract — the highest-risk cluster + +#### G1. An expired `resourceVersion` is invisible to the consumer + +- [x] Contract decision, then a test. **Done 2026-08-14**: Kuber now lists again + on expiry and delivers that list as a resync frame (`_resync`, + `src/simpleapi.jl`), covered by two testsets in `test/watch_recovery.jl`. + +`src/simpleapi.jl:296-299`: the in-stream 410 `ERROR` event is consumed by the +pump (`break`, no `put!`) and the watch restarts with `rv = nothing`. Nothing +reaches the caller. + +`K8sReflector` depends on seeing it. `src/K8sReflector.jl:171-192` matches the 410 +`Status`, parses the oldest-available resourceVersion out of the message, and +throws to trigger `cleanup(rf)` + `initial_load(…)` — i.e. **it invalidates its +cache**. On this branch that path is dead code. + +Mechanism, verified two ways: + +- The initial list runs **once**, in `list`/`get` before `_pump_watch` + (`src/simpleapi.jl:386-401`). On the expired path the pump sets `rv = nothing` + and re-issues only the *watch* call (`src/simpleapi.jl:268-272`) — it never + re-lists. +- A watch with no `resourceVersion` opens with synthetic `ADDED` events for + everything that currently exists. Confirmed against a live cluster: `curl -sN + '…/pods?watch=true'` with no `resourceVersion` replayed both existing pods as + `ADDED`. + +So after a 410 the reflector's store is re-upserted with current state, but nothing +ever tells it about objects deleted while the watch was gone — no `DELETED` event +is coming for them. **Phantom entries persist for the lifetime of the process.** + +This is a silent correctness regression for any cache-maintaining consumer. +`test/watch_recovery.jl`'s "expired resourceVersion starts over" testset asserted +the *opposite* side of it — that Kuber recovers — because that was the design +choice. + +**Resolution.** The contract is now *a list object on the stream means complete +current state*, and the pump upholds it: on the in-stream 410 it lists again, +pushes that list, and watches from its `resourceVersion`. That is what client-go's +reflector does, and it removes the phantom-entry class rather than delegating it — +a consumer that replaces its store on a list frame is correct without knowing +expiry exists. Three decisions behind it: + +- **One frame shape, not two.** The initial frame was already a bare list, so the + resync frame is too. A `KuberEvent("RESYNC", …)` marker was considered and + rejected: two shapes for "here is full state" is worse than one, and on the + `get` path (whose initial frame is a single object) a resync-typed event would + be stranger than a plain list. +- **The 410 `ERROR` frame is still not delivered.** The list carries strictly + more information than the `Status` did, and surfacing an error for a condition + Kuber recovers from would break consumers that treat `ERROR` as fatal. +- **`push_initial=false` suppresses the resync frame too** — it is the caller + saying "events only", and `watch(ctx, O, stream)` sets it. Such a consumer + still gets the recovery (the re-list is where the new `resourceVersion` comes + from) but not the state, and must track expiry itself. Narrow, documented, and + the shape `K8sReflector` will want anyway since it keeps its own store. + +This changes what [G2](#g2-caller-driven-re-establishment) needs from the +reflector port: it no longer has to catch a 410 and drive `cleanup` + +`initial_load` itself — replacing its store on a list frame does the same job. + +#### G2. Caller-driven re-establishment + +- [x] Test a caller that re-establishes its own watch in a loop. + **Done 2026-08-14**: "a caller can end a watch and re-establish it itself" + in `test/watch_recovery.jl`. +- [ ] Port `K8sReflector`'s loop to the shape below — **the test closing does not + mean the reflector works unchanged.** + +`packages/K8sReflector/src/K8sReflector.jl:216-245` wraps `Kuber.watch` in its own +`while true` and relies on `watch` *returning* (on long-poll timeout) so it can +re-establish with its own tracked resourceVersion. On this branch watches have no +deadline and the pump re-watches internally, so `watch` returns only when the +consumer closes the stream. The reflector's inner loop becomes unreachable. + +**That part does not change, and it is worth being precise about what closing +this box means.** A clean server close is re-watched internally by the pump — +including one caused by `timeout_seconds`, so there is no server-side way to make +`watch` hand control back either. The reflector's `while true` is dead code on +this branch no matter what. What the test establishes is that the *pattern* is +still expressible: a caller can drive re-establishment by ending the watch +deliberately, and resume from a version it tracked itself. + +The shape is a stream processor that leaves its event loop, which closes the +stream through the `finally` in `watch(streamprocessor, …)` and so ends the +watch: + +```julia +rv = nothing +while true + resume = rv === nothing ? NamedTuple() : (; resource_version = rv) + watch(ctx, list, :Pod; resume...) do stream + for item in stream + item isa KuberEvent || continue # the initial list frame + handle(item) + rv = Kuber._resource_version(item.object) + time_to_reestablish() && break # ends the watch + end + end +end +``` + +The assertion that makes this worth having is the last one: **the resumed round +issues no list request.** A caller supplying `resource_version` skips the initial +list, so a consumer keeping its own store pays for full state exactly once — the +useful half of the same `if !watch || resource_version === nothing` guard that +makes [G17](#g17-resource_version-is-accepted-and-ignored-on-non-watch-reads) a +bug on non-watch reads. + +#### G3. Event continuity across a Kuber-internal re-watch + +- [x] Assert no event is dropped or duplicated across the re-watch seam. + **Done 2026-08-14**: "no event is dropped or duplicated across a re-watch" + in `test/watch_recovery.jl`. + +`watch_recovery.jl` asserted that a resume happens with the right +resourceVersion. It did not assert continuity — exactly what a reflector's store +correctness depends on. + +Two things make the test more than a restatement of the resume assertion. The +first watch sends a **burst** of three events and then closes cleanly, so events +are in flight when the connection ends rather than arriving one per round trip; +and the consumer reads nothing until the seam has demonstrably passed (it waits +on the second watch request appearing, not on an event), so the burst has to +survive *buffered* across the re-watch. The assertions are the exact sequence +either side of the seam, `allunique`, an empty stream afterwards — a re-delivered +frame would be sitting there — and that the resume names the **last** version of +the burst rather than the first. + +**What it does not prove:** that no duplicate arrives, only that Kuber does not +manufacture one. A server that replays an event Kuber already delivered would +still reach the consumer, because Kuber does not deduplicate and cannot: watch +events carry no identity beyond the object and its version. A consumer that +needs exactly-once must key on `metadata.resourceversion` itself. That is the +same contract client-go gives, and it is worth stating because "continuity is +tested" invites the stronger reading. + +#### G4. Watch with a label selector across all namespaces + +- [x] Test a selector-scoped all-namespaces watch end-to-end. **Done + 2026-08-14**: `watch_selector_all_namespaces` in `test/runtests.jl`, run in + both live passes. + +The reflector always passes `label_selector` and `namespace=nothing` +(→ `_scopes(nothing)` = `(:cluster, :allns)`). The live suite watched `:Pod` in one +namespace with no selector; offline tests covered scope *resolution* only. + +The test mirrors `k8s_job_pod_monitoring.jl:66` rather than approximating it — +`:Pod`, `namespace=nothing`, and a selector built by `sel(marker, :in, id)` — and +covers both halves of the reflector's loop, the initial `get` that fills its store +and the watch that maintains it. Two things make it meaningful rather than merely +green: a selected pod is created in *two* namespaces, so a result carrying both +proves the read is all-namespaces rather than luckily single-namespace; and the +watch resumes from the list's `resourceVersion`, with an unselected pod created +*before* the selected one, so seeing the selected event proves the other was +filtered rather than merely late. A wait-and-hope negative would be flaky. + +Incidental coverage, not enough to close their boxes: `resource_version=` on a +live read ([G10](#g10-resource_version-on-a-list-or-get)) and labels written then +read back through `kuber_props` ([G9](#g9-open-struct-labels-and-annotations-on-write)). + +*Found while writing it:* **`put!` addresses the request with `ctx.namespace` and +ignores `metadata.namespace` on the object.** Creating an object whose metadata +names a different namespace is a 400 — "the namespace of the provided object does +not match the namespace sent on the request". Not a regression: `master` does the +same and does not even offer a `namespace` keyword on `put!`. Worth knowing when +building objects with explicit namespaces, which is why the test passes +`namespace=` explicitly. + +#### G5. Long-lived watch + +- [x] Decide whether this is testable in CI at all, or only as a manual probe. + **Decided 2026-08-15: both, once split.** The item bundled two claims with + very different costs, below as G5a and G5b. + +The reflector's watches live for the process lifetime. The longest test watch is +seconds. Nothing covers hours, `BOOKMARK` events, or a proxy/LB dropping an idle +connection. + +**What "long-lived" actually means is 30 to 60 minutes**, and it is a +configuration default rather than a property of watching. The apiserver closes +watches on its own timer: `--min-request-timeout` defaults to 1800 s and the +watch handler picks a randomized value in `[1800, 3600)` to spread reconnect +load, so an otherwise-unbounded watch is closed somewhere in that window. +Guaranteeing one close means running over an hour, per matrix entry, across three +Julia versions — which is what made this look untestable. + +But the *close* is what the code cares about, not the hour of waiting before it, +and a close is producible in seconds two ways: + +- **`timeoutseconds` on the request.** `?watch=true&timeoutSeconds=5` ends with + exactly the clean close the 30-minute timer produces — verified against a live + cluster on 2026-08-15. +- **`--min-request-timeout` on the apiserver**, as a kind `kubeadmConfigPatches` + → `apiServer.extraArgs` entry, which closes *every* watch on that cadence + without the caller asking for it. + +So the item splits along what compression can reach. + +##### G5a. Server-initiated close, against a real apiserver — CI-sized + +- [x] Cover the compressible half live: a watch the **server** ends is + re-established and loses nothing; `allowwatchbookmarks=true` produces + `BOOKMARK` events and they do not disturb the stream or the tracked + `resourceVersion`; a resync happens when the `resourceVersion` has expired. + **Done 2026-08-15**: `long_lived_watch` in `test/runtests.jl`, about twelve + seconds of wall time, live suite 816 → 898 assertions. + +Close-and-re-watch and resync are already covered against +`test/watch_recovery.jl`'s fake apiserver, so for those two this is a widening +rather than a gap: what is untested is that a *real* apiserver ends a watch the +way the fake does. + +**`BOOKMARK` is the exception — nothing exercises it anywhere.** Kuber never sets +`allowwatchbookmarks`, `watch_recovery.jl` never emits one, and +`test/runtests.jl:553` only asserts that one would be *tolerated* if it arrived, +which is not the same as producing one. A real bookmark carries an object holding +nothing but a `resourceVersion` — a shape that has never been fed through +`KuberEvent`, and one the pump must not mistake for a normal event when it +updates the tracked version. That makes the bookmark leg the part of G5a most +likely to find something. + +Cost is seconds of wall time, and no cluster configuration: `timeoutseconds` +carried all three legs, so the kind `kubeadmConfigPatches` route was not needed. + +**What it found: a race in the events-only form, and one rule confirmed on a +payload it was never tested against.** + +The race is in `watch(ctx, O, stream)`, which takes no `resource_version`: it +lists internally to learn where to resume and then **discards that list**, so an +object created between the caller's `watch` call and that internal list is inside +the list, is thrown away with it, and is never announced. It is not a defect — +the form is documented as events-only — but "no initial state" and "a silent hole +at establish time" are different promises, and only the first was written down. +The window is small enough that it does not show locally: the first run passed on +k3s and failed in CI on kind, where the create won the race. A consumer that +wants no gap has to seed the version itself, which is what `K8sReflector` and +`watch_selector_all_namespaces` already do and what this test now does. Recorded +in `README.md` alongside the events-only form. A bookmark's object is the watched kind +carrying `metadata.resourceVersion` and, on a `Pod`, `spec.containers` as an +explicit `null` — a *required* array property. It decodes under strict validation +only because patch rule §2 makes array properties nullable, the Go-nil-slice +rule, which until now was exercised against list and read payloads rather than a +watch frame. The test asserts that null rather than skipping over it, so a +regression in §2 fails here too. Resuming from `resourceVersion=1` also confirmed +the apiserver answers an expired version with an in-stream `ERROR`/410 exactly as +the fake does, with no wait for etcd to compact. + +##### G5b. Duration itself — manual probe + +- [x] Keep as a documented manual probe, not a CI job. **Done 2026-08-15**: + `test/watch_longevity.jl`, alongside `watch_latency.jl` and + `characterize_retries.jl`, listed with them in `CLAUDE.md`. + +What compression cannot reach: file-descriptor and memory growth across hours of +re-watching, a load balancer or proxy dropping an idle connection, an apiserver +restart or rollout mid-watch, HTTP/2 `GOAWAY`. These need real wall time or real +infrastructure — and the LB idle timeout (60–350 s on the common cloud +balancers) is the one JuliaRun most likely meets in production, while being the +one a kind cluster cannot produce at all, since there is no intermediary. + +`test/watch_longevity.jl` carries it, in the shape `watch_latency.jl` set: a +probe outside `runtests.jl`, run by hand against a real cluster. +`julia --project test/watch_longevity.jl [hours]`, default two. + +Reconnects are deliberately *not* what it counts — Kuber re-establishes silently, +which is the whole point of it — so every heartbeat it creates an object and +times how long the watcher takes to see it. A missed heartbeat means the watch +stopped delivering, whatever stopped it. Resyncs are visible as list frames and +are counted; bookmarks, open descriptors, RSS and post-collection live bytes are +sampled alongside. + +**Run it through whatever proxy or balancer the deployment has.** Against a local +apiserver it cannot answer the idle-drop question at all, because there is no +intermediary to drop anything — and that is the failure JuliaRun is most likely +to meet. + +*Found while writing it, worth repeating anywhere growth gets measured:* the +first run showed open descriptors climbing by exactly one per heartbeat, and the +leak was in the probe. `rss_mb` read `/proc/self/status` with `eachline` and +returned early on the `VmRSS:` line, which leaves the stream open — so the +function reporting descriptor counts was the thing consuming them. Confirmed in +isolation (20 calls, 20 descriptors) and fixed to `readlines`. Kuber itself holds +one socket for requests and one for the watch, flat across 126 events. + +### Kind coverage + +#### G6. Consumers write kinds the live suite never touches + +- [x] Extend the live suite to the kinds marked **no** below. + **Done 2026-08-14**: `create_delete_more_kinds` in `test/runtests.jl`, + run in both live passes. + +The live suite submitted Pod, Service, Job and Deployment. ReplicationController +is built but never submitted; HPA `v1`/`v2` objects are built client-side only +(to exercise versioned typing); CronJob appeared solely in a `@test_throws +KeyError` for the removed `batch/v1beta1`. + +| Kind | JuliaRun | JuliaHub monorepo | In live suite? | +|---|---|---|---| +| Job | 26 | | yes | +| Deployment | 23 | 20 | yes | +| ReplicaSet | 12 | | yes — G6 | +| Service | 11 | | yes | +| Node | 10 | 1 | yes — patched by G8 (no consumer creates one) | +| Pod | 7 | 3 | yes | +| Secret | 6 | 2 | yes — created, patched and deleted by G16 | +| DaemonSet | 4 | | yes — G6 | +| CronJob | 4 | | yes — G6 | +| Namespace | 3 | 8 | yes — created and deleted by G13 | +| RoleBinding | 2 | | yes — G6 | +| PersistentVolume | | 4 | yes — G6 | +| PersistentVolumeClaim | | 3 | yes — G6 | +| NetworkPolicy | | 3 | yes — G6 | +| ConfigMap | | 2 | yes — created and deleted by G13 | + +This matters more here than it would on `master`: strict response validation +checks each kind's schemas independently, and **two of the eight patch rules were +found exactly this way** (`*/*` request bodies on `put!`, DELETE 2xx on +`delete!`). Each untested kind is an unexercised set of schemas. + +Each kind is taken through the four paths that have distinct schemas — create, +a `get` once the controller has written a status, a `list` with the object still +in it, and delete — because a `get` issued straight after `put!` decodes an +empty status block and checks almost none of the kind's schema. Nothing +schedules a workload (`replicas: 0`, a `nodeSelector` no node carries, +`suspend: true`), which also keeps the concurrent `:Pod` watch's assertions +clean. Two group modules — `rbac.authorization.k8s.io/v1` and +`networking.k8s.io/v1` — had never been reached live at all before this. + +The fixtures copy the real consumer templates, with two deliberate departures: +the RoleBinding points at a Role that does not exist rather than reproducing +JuliaRun's `ClusterRole/admin` grant (RBAC permits a dangling `roleRef`, so the +schema is identical), and the NetworkPolicy selects a label no pod carries +rather than using JobLoops' empty selector, which is deny-all-ingress for the +namespace and would be a live hazard on a cluster whose CNI enforces. + +**Result: seven kinds, no new patch rule.** Given that two of the six existing +rules were found by submitting a kind for the first time, the plausible outcome +was a seventh — and that would have meant a full regeneration rather than a +testset. Every one of these kinds round-tripped under strict response validation +unchanged, across four group modules. That is evidence about the *patch set*, +not just about these kinds: the rules generalise past the handful of kinds they +were derived from. + +Two forms fell out of this that are verb-layer coverage rather than schema +coverage: `get(ctx, :DaemonSet; label_selector=…)` with no name — the shape +`JuliaRun/src/kubernetes/api.jl:993` and `provisioning.jl:110` use, which +resolves to the *list* operation and answers with a `…List` — and the `:cluster` +scope fallback for a cluster-scoped kind other than Namespace +(PersistentVolume). + +#### G7. Secret round-trip + +- [x] Test base64 `data` / `stringData` through the new codec. + **Done 2026-08-14**: `secret_round_trip` in `test/runtests.jl`. + +`JuliaRun/src/kubernetes/api.jl:220-248` builds Secrets with `data`, and the +values it puts there are raw `Vector{UInt8}` — `_as_binary_secret` +(`api.jl:203-214`) base64-*decodes* anything that looks base64 before handing it +over, so what reaches Kuber is always bytes. The 0.2.x client base64-encoded +them onto the wire because the field is `format: byte`; the 1.0 runtime does the +same in both directions. + +**The values survive the port unchanged. The container does not.** `data` is an +open struct now, so `Secret(; data=bindata)` has to become +`Secret(; data=SecretData(additional_properties=bindata))` — the same +[G12](#g12-resource-limits-are-an-open-struct)-class change, on the one field +where the payload is binary. + +The test writes bytes that are deliberately not valid UTF-8 +(`0x00 0xff 0xfe 0x01 0x80`), so a round trip that "works" by treating the value +as text cannot pass it. Two behaviours it pins that are easy to guess wrong: + +- **`stringData` is write-only.** The apiserver folds it into `data` and never + returns it, so a consumer that writes it must not expect to read it back. +- **A merge patch merges the map, it does not replace it.** RFC 7386 merges key + by key; only an explicit `null` removes a key. Patching `data` with just + `token` leaves `binary` and `plain` intact. *This was asserted the wrong way + round first and the live run corrected it* — worth recording, because the + wrong guess is the dangerous direction only in reverse: believing it merges + when it replaced would silently drop every other secret in the object. + `update_secret` sends the whole desired map anyway, so it is unaffected either + way. + +See also [G12a](#g12a-secretdata-decodes-to-bytes-not-base64-text) for the read +side: what comes back is already-decoded bytes, so the 0.2.x +`String(base64decode(v))` idiom now decodes twice and yields rubbish rather than +an error. + +#### G8. Node and Namespace as cluster-scoped writes + +- [x] Cover a cluster-scoped create/delete. **Done 2026-08-14** across three + testsets: Namespace by `create_delete_from_dicts` (G13), PersistentVolume + by `create_delete_more_kinds` (G6), and Node by `cluster_scoped_writes`. + +Both appeared in the live suite only as reads; JobLoops creates Namespaces +(`services/JobLoops/src/hot_standby.jl:526`). + +**Node is not a create/delete, and should not be tested as one.** No consumer +creates a Node: the monorepo's `set_node_label`, `set_node_cordon` and +`taint_update_patch` all patch an existing one. Creating a Node object through +the API works, but it would be testing an operation nobody performs *and* +leaving a kubelet-less `NotReady` node on the cluster for metrics-server and the +scheduler to trip over. So the testset patches a real node and puts it back, +in the two shapes consumers send: + +- a **merge patch** setting a label, then an explicit `null` removing it. That + pins the complement of what [G7](#g7-secret-round-trip) found: unmentioned + keys survive a merge patch, and `null` is the only way to delete one. +- a **json-patch whose value is a nested array of dicts** — `taint_update_patch`'s + shape — appending via `/spec/taints/-` rather than replacing `/spec/taints`, + so the node's existing taints are untouched. A control-plane node carries one, + and dropping it would be a live change to the cluster rather than a test. + +The taint is `PreferNoSchedule` and nothing cordons, because the rest of the +live suite schedules pods on that same node. + +Reading a Node by name also exercises the `:cluster` scope fallback for a kind +that is neither Namespace nor PersistentVolume: `ctx.namespace` is `default`, and +the request still goes to `/api/v1/nodes/` because the `:namespaced` +lookup falls through. + +### Data-shape gaps + +#### G9. Open-struct labels and annotations on write + +- [x] `put!` with labels, read them back off the server. + **Done 2026-08-14**: the G9 block of `data_shapes` in `test/runtests.jl`. + +`test/helpers.jl:73-89` covers `kuber_props` on a hand-built object. Nothing covered +the round trip, nor the `services/JobLoops/src/networkpolicy.jl:114` pattern +(`labels["version"]`, which now needs `kuber_props`). + +The round trip carries labels, annotations and `data` on one ConfigMap, and +reads each back with `kuber_props`. The assertion that earns its place is the +negative one: `Kuber._field(metadata.labels)` is **not** an `AbstractDict`, and +indexing it the 0.2.x way is a `MethodError`. That is the shape of the +`networkpolicy.jl:114` break — a hard failure at the read, not a wrong answer. + +#### G10. `resource_version=` on a list or get + +- [x] Test the live "not older than" read. + **Done 2026-08-14**, and it found that the keyword does nothing. The + *fix* is [G17](#g17-resource_version-is-accepted-and-ignored-on-non-watch-reads); + this box covers the test that pins the behaviour. + +`packages/K8sReflector/src/K8sReflector.jl:136-141` passes it to `Kuber.get`. The +`_op_kwargs` translation is unit-tested; the live behaviour was not — and the live +behaviour turns out to be that the parameter never reaches the server on a +non-watch read. The test asserts the trap rather than the intent: the same +impossible resource version errors when passed as `resourceversion=` (the +generated spelling, a real query parameter) and succeeds when passed as +`resource_version=` (the documented spelling, which is dropped). + +#### G11. `.items` and `metadata.resourceversion` off a real list + +- [x] Assert the consumer-facing shape of a live list result. + **Done 2026-08-14**: the G11 block of `data_shapes`. + +`_resource_version` was tested on synthetic dicts and objects; live list results +were asserted only as `isa …List`. Now: `hasproperty(result, :items)` — the guard +`provisioning.jl:111` actually uses — `items` a `Vector` of the item type and +non-empty (the test creates into the collection first, so the assertion means +something), `_resource_version(result)` a non-empty `String` equal to +`result.metadata.resourceversion`, and a per-item resource version for every +item, which is what `K8sReflector.jl:12` keys its store on. + +#### G12a. `Secret.data` decodes to bytes, not base64 text + +- [x] Sweep consumer reads of `Secret`/`ConfigMap` binary data. + **Done 2026-08-14.** One real site, below. +- [ ] Fix `JuliaRunPool.jl:135-136` in the monorepo — not a Kuber change. + +*Found 2026-08-14 while testing G16's typed-model patch.* `Secret.data` values are +`format: byte` in the OpenAPI document, and the 1.0 runtime decodes those to +`Vector{UInt8}` — already base64-decoded. A consumer that does +`String(base64decode(secret.data["x"]))`, the natural 0.2.x idiom, now decodes +twice and gets rubbish rather than an error. `String(copy(v))` is the new form. + +**The sweep found one site, and it fails silently.** +`packages/JuliaRunPool/src/JuliaRunPool.jl:135-136`: + +```julia +existing_data = get(get(existing_secret, "data", Dict()), ".dockerconfigjson", "") +if existing_data == dockerconfigjson +``` + +`existing_secret` comes from `JuliaRun.get(ctx, :Secret, secret_name)`, so it is +a typed model — `Base.get(model, "data", …)` has no method, on this branch or on +`master`. Past that, the comparison is against `dockerconfigjson`, the +**base64-encoded** config from JuliaHub's config file. On 0.2.x `Secret.data` +came back as base64 text and that comparison was right; here the value is a +`Vector{UInt8}` of *plaintext*, so it can never equal a base64 `String`. The +branch's purpose is to skip a redundant write, so the failure is not an error — +the image-pull secret is rewritten on every namespace creation, forever. The file +even carries a comment reasoning correctly about the *write* side while the read +side compares the wrong things. + +The form that works: + +```julia +existing = Kuber.kuber_props(existing_secret.data) +existing_data = get(existing, ".dockerconfigjson", UInt8[]) +if String(copy(existing_data)) == dockerconfigjson_decoded +``` + +**Everything else is clear.** All five `base64decode` sites in `JuliaRun` are +kubeconfig parsing (`utils.jl:71`, `utils.jl:104`), env packing (`api.jl:493`), +or the *write* side (`api.jl:208`, `_as_binary_secret`, which G7 confirms still +works). In the monorepo, `kill_k8s.jl:33` and `monitoring_loop.jl:442-445` read +base64 blobs out of the **database** via `db_get_job_envsecrets`, not off a +Kubernetes Secret, so Kuber's codec never touches them. + +#### G12. Resource limits are an open struct + +- [x] Test `kuber_props` on `resources.limits` / `.requests`. + **Done 2026-08-14**: the G12 block of `data_shapes` in `test/runtests.jl`. +- [ ] Fix `clustermgmt.jl:186-194` and `:281-285` in JuliaRun — not a Kuber + change. Two breaks, one of them silent. + +`ResourceRequirements.limits` is `IoK8sApiCoreV1ResourceRequirementsLimits`, +whose only field is +`additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity}`, so +`limits["cpu"]` must become `kuber_props(limits)["cpu"]`. + +*(An earlier revision of this item named the type +`IoK8sApiCoreV1ContainerResourcesLimits`. That was accurate when written: +`Container.resources` was a positional copy of `ResourceRequirements`, so its +maps were named after the copy. Patch rule §7 collapsed those, so `resources` is +now the shared type across every kind that embeds a pod template — one fewer +thing for a consumer to get wrong.)* + +Quantity itself is fine: still a struct with a single `value` field +(`Union{Float64,String}`), so JuliaRun's `string(cpu.value)` +(`src/kubernetes/api.jl:1841`) and `conv_units(::Typedefs.CoreV1.Quantity)` +(`src/kubernetes/clustermgmt.jl:20`) survive structurally. Only the type +*identity* differs, which is C1's problem. + +**The audit found two breaks in `clustermgmt.jl`, and the quieter one is worse.** + +```julia +# :186-194 — container_resource +if hasproperty(cont, :resources) + resources = cont.resources + if hasproperty(resources, :requests) + return resources.requests + elseif hasproperty(resources, :limits) + return resources.limits + end +end + +# :281-285 — the caller +("cpu" in keys(res)) && (nodestate.cpu.free -= conv_units(res["cpu"])) +``` + +The loud one is `keys(res)` and `res["cpu"]`: `res` is an open struct, so both +are `MethodError`s. Mechanical to fix with `kuber_props`. + +The quiet one is `hasproperty`. On 0.2.x an unset field was missing or `nothing`; +on 1.0 **every field exists** and an unset one is `ABSENT`. So +`hasproperty(resources, :requests)` is now *always* true, and +`container_resource` returns `ABSENT` for a container that declares only +`limits` — it never reaches the `elseif`. The caller's `res === nothing` guard +does not catch `ABSENT`, so scheduling arithmetic would run against it. The test +covers the Kuber-side shape; this one needs `Kuber._field`-style checks at the +call site, and it is the pattern to grep for across both consumers rather than a +single line to fix. + +That pattern is also why C2 is bigger than its table says — see the +`getpropertyat`/`haspropertyat` row added there. + +#### G13. `put!(ctx, O::Symbol, dict)` — the dominant consumer form — is untested + +- [x] One testset. Highest value per line of test code in this document. + **Done 2026-08-14**: `create_delete_from_dicts` in `test/runtests.jl`, run + in both live passes. + +The testset is modelled on `hot_standby.jl` rather than written from scratch: the +namespace dict is that file's literal shape, and the deployment comes from +`JSON.parse`, which is what a rendered template actually produces. It covers the +cluster-scoped and namespaced cases, that nested arrays and string maps survive +the round trip, that the `apiVersion` comes off the dict rather than off +discovery, and the kind-completion path (a dict with no `"kind"`, which Kuber +fills in from the symbol without mutating the caller's dictionary). + +**Writing it turned up why the wider signature is load-bearing rather than +incidental.** On JSON.jl 1.x `JSON.parse` returns a `JSON.Object`, which is an +`AbstractDict` but not a `Dict`. `master`'s three methods are +`v::T<:OpenAPI.APIModel`, `v::Dict{String,Any}` and `v::T<:OpenAPI.APIModel` +again — all narrow — so a parsed template matches none of them and +`put!(ctx, :Deployment, spec)` is a `MethodError`. `master` allows JSON 1 in +`[compat]`, so that is a live hazard there, not a hypothetical. This branch takes +`v::AbstractDict`, which covers both. The two cases in the testset are now +deliberately different shapes: a plain `Dict` for the namespace, a `JSON.Object` +for the deployment. + +Two smaller improvements over `master` in the same method, worth keeping: it +reads `haskey(v, "kind")` rather than `v["kind"]`, which on `master` is a +`KeyError` when the key is absent — the very case the code is trying to handle — +and it merges into a fresh dictionary instead of writing `"kind"` into the +caller's. + +Trial tests only ever call the 2-arg model form (`put!(ctx, nginx_pod)`). +`services/JobLoops/src/hot_standby.jl:526,541,545` uses +`Kuber.put!(ctx, :Deployment, spec)` and `(ctx, :Namespace, …)`. The signature +exists and is in fact *wider* than master's (`v::AbstractDict` vs +`Dict{String,Any}`, plus an untyped fallback at `src/simpleapi.jl:476`), so this is +a coverage gap rather than a break — and it is the shape most production writes go +through. + +### Error and retry paths + +#### G14. Live retryable statuses + +- [x] Exercise a real 429/503/504, and retries interacting with a watch establish + failure. **Done 2026-08-14**: `test/retries.jl`, in `runtests.jl`. + +`k8s_retry_cond` was characterized offline only, by +`test/characterize_retries.jl`, which pins the *exception types* the runtime +raises, is not in `runtests.jl`, and never drives the retry loop. + +**A live 429 or 503 is not the way to get one.** Provoking real load-shedding +from an apiserver is neither reliable nor cheap, and the interesting variable is +the status, not the cluster. `test/retries.jl` uses a server that always fails +with a chosen status and counts requests, so "retried" is the difference between +one request and several rather than something inferred from timing. Offline and +deterministic. + +Measured, with HTTP.jl's own retry layer switched off so the count reflects +Kuber's loop alone (`max_tries=3`): + +| Status | Requests | `is_retryable` | +|---|---|---| +| 500, 502, 503, 504 | 4 | yes | +| 429 | 1 | no — see [G19](#g19-429-is-not-retried) | +| 404, 409, 422 | 1 | no | + +Two things fell out of writing it, both shared with `master`: +[G19](#g19-429-is-not-retried) and +[G20](#g20-http-jl-retries-underneath-kuber-so-max_tries-does-not-bound-requests). + +#### G19. 429 is not retried + +- [x] Add 429 to `k8s_retryable_codes`, ideally honouring `Retry-After`. + **Done 2026-08-14**: both, `src/helpers.jl`; covered by `test/retries.jl`. + +Kubernetes' priority-and-fairness layer sheds load with **429 plus a +`Retry-After` header**, and client-go retries it. `k8s_retryable_codes` is +`[0, 500, 501, 502, 503, 504]` — on this branch *and* on `master` — so a +throttled call fails immediately instead of backing off. A busy cluster +therefore surfaces errors to consumers that client-go would have absorbed. + +**Fixed, together with G20, because the two only make sense together.** Before +G20, HTTP.jl retried 429 underneath anyway, so the observable behaviour was +"retried, but not by Kuber, not with `Retry-After` honoured, and not counted by +`max_tries`" — worse than either answer taken alone. With HTTP.jl's layer off, +Kuber's list is the whole story, so 429 had to join it. + +`Retry-After` is honoured as a *floor* on the backoff: it only ever lengthens a +wait. Three deliberate limits, all in `_retry_after`: + +- **429 only.** A 5xx may carry the header too, but honouring an arbitrary + server-supplied delay on every transient failure changes the timing of every + retry in the client. 429 is where the server is deliberately pacing us. +- **Capped at 30 s** (`RETRY_AFTER_CAP`), so a large or hostile value cannot + park a call indefinitely. +- **Delta-seconds only.** `Retry-After` may also be an HTTP date, which + Kubernetes does not send; `tryparse` returns `nothing` for one and the backoff + is used instead, which is the safe direction. + +Honouring the header is why `k8s_retry` is now an explicit loop rather than +`Base.retry`: `Base.retry` takes its delays from an iterator that never sees the +exception, so the server's own pacing is unreachable from it. + +#### G20. HTTP.jl retries underneath Kuber, so `max_tries` does not bound requests + +- [x] Either set `retry=false` and own retrying entirely, or document the + multiplier. **Done 2026-08-14**: Kuber owns it. `_call_options` sets + `retry=false` on every call, and `max_tries` now counts attempts. + +Kuber's `k8s_retry` is not the only retry loop in the stack: HTTP.jl 2.x retries +idempotent requests on a retryable status by default. Measured at this pin, +against a server that always answers 503: + +| `max_tries` | Requests, HTTP.jl retry on | Requests, `retry=false` | +|---|---|---| +| 1 | 10 | 2 | +| 2 | 15 | 3 | +| 3 | 20 | 4 | + +Each Kuber attempt cost five HTTP requests, so `set_retries(ctx; count=5)` +against a struggling apiserver was thirty requests, not six, with both backoffs +composing. + +**`max_tries` was also off by one.** `k8s_delay` built +`ExponentialBackOff(n=max_tries)` and `Base.retry` performs `n` retries *on top +of* the first attempt, so `max_tries=1` was two requests. Mutating calls take +`retries(ctx, true) == 1`, so **a `put!` whose first attempt failed with a 5xx +was retried once** — not what "only non-mutating calls retry by default" +implies, and the direction that risks a duplicate create. `master` computes the +delays identically, so none of this was new; none of it was written down either. + +**Resolved by having Kuber own retrying.** `_call_options` merges +`retry = false` into every call's options, so HTTP.jl's layer is off unless a +caller puts it back with `set_request_options(ctx; retry=true)`. Kuber already +has a curated policy — a status list, a mutating-vs-not rule, `is_retryable` as +its public face — and HTTP.jl's layer silently contradicted all three. Now +`max_tries` is a budget of *requests*, which is what it reads as. + +`k8s_delay` clamps to `max(0, max_tries - 1)` delays, so `max_tries` counts +attempts. Two consequences worth stating, because both are visible: + +- `default_retries = 5` is now **5 attempts, not 6**. A small reduction. +- a mutating call is now **1 attempt, not 2**, which is the contract + `set_retries(all_apis=false)` always claimed. + +The option is set in `_call_options` rather than on the context because the +context's `client_kwargs` are passed to the generated `Client` constructor, +which takes no `retry` — putting it there is a `MethodError` on the first call. + +#### G15. Exception classification for consumers + +- [x] Export a supported "was this transient?" predicate and pin it with a test. + **Done 2026-08-14**: `Kuber.is_retryable`, `test/helpers.jl`. + +With `OpenAPI.Clients` gone (C2), consumers had no supported way to ask. Kuber had +the logic internally but did not export it, and no test pinned it as public +behaviour. + +`is_retryable(e)` is `k8s_retry_cond`'s answer over an unwrapped exception. Named +for what it means rather than for what it replaces: it is exactly "would Kuber +retry this", which is the question a consumer driving its own calls has to answer, +and it matches the internal vocabulary (`k8s_retryable_codes`, `k8s_retry_cond`). + +Two boundaries the test pins, because both are easy to get wrong later: + +- **`TaskFailedException`/`CompositeException` are unwrapped.** `watch(processor, + ctx, …)` runs two tasks under `@sync`, so a failure arrives wrapped. A predicate + that did not unwrap would answer `false` for every watch failure — the exact + case it exists for. A composite carrying more than one exception is left alone: + no single cause to classify. +- **A `DecodeError` is not retryable.** A response that does not match the schema + is spec drift. The watch pump separately recovers from a truncated stream item, + which arrives the same way but means the connection died mid-frame. + +#### G16. `update!` patch coverage + +- [x] Enumerate the patch types and kinds JobLoops actually patches, then test + them. **Done 2026-08-14** — and the enumeration found a break, now + [C8](#c8-json-patches-did-not-encode-at-all). + +The enumeration, across both consumers: + +| Caller | Media type | Patch shape | Kind | +|---|---|---|---| +| `julia_parallel_scale` | json-patch | `Vector{Dict{String,Any}}`, 1–2 ops | Job, Deployment | +| `taint_update_patch` | json-patch | vector whose `value` is a nested vector of dicts | Node | +| `julia_update_job` | json-patch | vector whose `value` is a pod template | Deployment | +| `hot_standby.jl:428` | json-patch | `Vector{Dict{String,Any}}` | Deployment | +| `set_node_cordon` / `set_node_label` | merge-patch | parsed JSON object | Node | +| `api.jl:252` | merge-patch | a **typed model** (`Secret`) | Secret | +| `networkpolicy.jl:142` | json-patch | JSON **text** of an object — see [C9](#c9-a-live-defect-in-jobloops-found-in-passing) | NetworkPolicy | + +So json-patch is the *majority* shape in production, and it was exactly the one +that could not encode. The live suite now patches a Deployment with a +single-operation and a two-operation json-patch, with JSON text, with a strategic +merge patch, and a Secret with a typed model; `test/simpleapi.jl` covers the +per-media body types offline, including the nested-vector taint shape and that +the object model still refuses an array. + +*Noted 2026-08-14 while writing [G13](#g13-putctx-osymbol-dict--the-dominant-consumer-form--is-untested):* +`hot_standby.jl:419-434` scales a deployment with +`application/json-patch+json` and a **`Vector` of operation dictionaries** +(`[Dict("op" => "replace", "path" => "/spec/replicas", "value" => n)]`), not a +dictionary. That is a different body shape from the merge patch the suite +covers, and `OP_BODIES` says a patch body has to be built as the generated +`Patch` type, so whether a bare vector survives that path is exactly the thing +to test first here. + +#### G17. `resource_version=` was accepted and ignored on non-watch reads + + +- [x] `list` — forward `resource_version` to the operation's `resourceversion` + parameter on the non-watch path. **Done 2026-08-14**, `src/simpleapi.jl`; + the G10 testset now asserts the forwarding instead of the trap. +- [x] `get` — a patch rule declaring the parameter k8s omits. + **Done 2026-08-14**: `patch_k8s_spec.jq` §8 plus the same forwarding in + `get`. Held back until G19/G20 were settled; see below for why. + +*Found 2026-08-14 while writing [G10](#g10-resource_version-on-a-list-or-get).* +`list` and `get` both take a `resource_version` keyword, and on the non-watch +path neither sends it: `if !watch || resource_version === nothing` computes the +result without ever putting it on the wire. It is consulted only to seed a +watch. + +**`master` does exactly the same** (`git show master:src/simpleapi.jl`, the same +guard in all four verbs), so this is a shared limitation rather than something +the port broke — which is why it is not a blocker, and why the test that found +it ticks G10 rather than failing. + +Two halves, with quite different costs: + +- **`list` was a one-line fix, and is done.** The generated list operations + declare `resourceversion` (and `resourceversionmatch`), so the parameter + existed and worked — `list(ctx, :Pod; resourceversion="0")` reached the server + already. Only the documented spelling was dropped, and the trap was that the + two spellings differ by one underscore with one of them silently doing + nothing. `list` now forwards it on the non-watch path; inside a watch + `resource_version` still means "resume from here" and is consumed by the pump, + which is a different thing and stays that way. +- **`get` could not be fixed by forwarding — it needed a patch rule, and now has + one.** k8s's document declared only `pretty` on read operations, no + `resourceVersion`, even though the apiserver honours it. *Verified against a + live cluster:* `GET …/configmaps/x?resourceVersion=0` answers 200, and an + impossible version answers **504 "Too large resource version"**. So the + omission was a documentation bug in the same class as the other rules. + + **It was held back until G19/G20 were settled**, and that sequencing was the + point. Rules 1–7 make the document describe what the server already does with + requests Kuber already sends; this one changes which requests Kuber can + *construct*, and its natural failure is a 504 that blocks for the apiserver's + wait. While `max_tries=1` still meant ten requests, adding it would have + stacked two unknowns. With the retry budget real, it is one. + + §8 adds the parameter only to paths ending in `{name}` — the object read + itself, not subresources like `pods/log`, where a resource version is + meaningless. The live test asserts an impossible version now answers 504 + through `get`, which is what proves the rule reached the wire rather than just + the document. + + The alternative considered and not taken: routing a versioned single read + through the list operation with a `metadata.name` field selector, which + `get`'s watch path already does for its own reasons. That works without a + patch rule but makes a read cost a list, and leaves the document still lying. + +This mattered to `K8sReflector`, which passes `resource_version` to `Kuber.get` +(`K8sReflector.jl:136-141`) to re-read at a known version. That call had never +done what it reads as — on either branch — and now does. The live suite asserts +that exact shape: read, keep the version, read again not older than it. + +#### G18. List items are a different type from the standalone object + + +- [x] Add a seventh patch rule collapsing the `allOf` wrapper, and regenerate. + **Done 2026-08-14**: `patch_k8s_spec.jq` §7. It reached much further than + list items — see below. + +*Found 2026-08-14 while writing [G11](#g11-items-and-metadataresourceversion-off-a-real-list), +by an assertion that looked too obvious to fail.* + +```julia +item = list(ctx, :Pod; namespace="kube-system").items[1] +typeof(item) # IoK8sApiCoreV1PodListItemsItem +item isa Kuber.kind_to_type(ctx, :Pod) # false +``` + +**On `master`, `PodList.items` is `Vector{IoK8sApiCoreV1Pod}`** — the same type +as a standalone Pod — so this is a regression, not an inherited quirk. It +applies to **every list kind in every group module**, checked on `PodList`, +`ServiceList`, `NamespaceList`, `SecretList`, `ConfigMapList` and +`DeploymentList`. + +**Cause.** The k8s document writes the element schema as an `allOf` wrapper with +a sibling keyword rather than a bare reference: + +```json +"items": {"allOf": [{"$ref": "#/components/schemas/io.k8s.api.core.v1.Pod"}], + "default": {}} +``` + +A `$ref` with siblings is a *new* schema, so the generator mints one and names +it after its position. The `"default": {}` is meaningless on an object +reference, which puts this in exactly the same class as the six existing patch +rules: the document says something it does not mean. + +**What still works, and what does not.** Field names are identical and the +nested types were shared (`item.spec` was `IoK8sApiCoreV1PodSpec2`, the same +type the standalone Pod's `spec` had), so every *read* through a list item +behaved correctly — which is why G6, G13 and G4 all passed without noticing. What breaks +is type identity: + +- `isa(x, kind_to_type(ctx, :Pod))` — `JuliaRun/src/kubernetes/api.jl:1418` + compares `Tw === Kuber.kind_to_type(cm.ctx, "ReplicaSet")` on an object that + came out of a list. +- any consumer signature typed on a generated model that is fed from a list. +- `kuber_kind(item)` is `""`, so the object forms of `delete!`/`update!` reject a + list item (`ArgumentError: kind must be specified`). This half is **not** a + regression — k8s never populates `kind` on list items, and master read the + same absent field — but it is worth knowing, because "list it, then delete it" + is an obvious thing to write. + +**The fix reached much further than list items.** k8s never writes a bare +`$ref` for *any* property — the `allOf` wrapper is how it hangs a `description` +beside one, because a `$ref` with siblings is undefined in OAS 3.0. So the +generator was minting a type per use site everywhere, not just under `items`: + +- `Pod.spec` was `IoK8sApiCoreV1PodSpec2` — the `2` disambiguating it from the + real `PodSpec` component, **which nothing referenced**. +- every kind had its own `…Metadata` instead of the shared `ObjectMeta`. +- every `…List.items` had its own element type, which is the symptom G11 hit. + +1290 sites across the 18 documents, in exactly two positions: property schemas +and the `items` of array properties. The result: + +| | Before | After | +|---|---|---| +| generated types | 2252 | **1098** | +| `src/ApiImpl/generated/` | 24 MB | **18 MB** | + +Two things about the rule worth keeping: + +- **It is scoped to those two positions, not walked recursively.** + `apiextensions`' `JSONSchemaProps` describes JSON Schema itself, so it has + *properties named* `allOf`, `nullable` and `items`. A recursive walk rewrites + that map and silently corrupts the CRD document. +- **It is guarded on shape** — a single-element `allOf` whose element is a bare + `$ref` — rather than on the survey that said every `allOf` looks like that. A + future spec bump that introduces a two-element `allOf`, or a `$ref` carrying + siblings, is left alone to be noticed. + +`test/registry.jl` gates it on type *identity* across four kinds in three group +modules (`fieldtype(Pod, :spec) === PodSpec`, `eltype(PodList.items) === Pod`), +plus no name ending in `ListItemsItem` surviving anywhere. A collapse that +produced an alias per use site would shrink the diff by as much and still be +wrong. + +The `kuber_kind(item) == ""` half is unchanged and unfixable here: k8s does not +populate `kind` on list items, so the object forms of `delete!`/`update!` still +reject one. The live suite now asserts that too, so "list it, then delete it" +fails loudly rather than surprisingly. + +--- + +## Consumer checklist + +The same work as Part 1 and Part 2, arranged by the repository that has to do it +rather than by the gap it came from — a port is worked through a file at a time, +not a gap at a time. **The `C…`/`G…` sections remain the argument; this is an +index into them.** Its boxes are per call site, so a gap's own box closes when +every site listed under it here is ticked. + +Snapshot of two trees at the pins in [Scope of the survey](#scope-of-the-survey); +`JuliaHubK8sApi` is a shared package and may have consumers outside them. Re-run +the audit before starting. + +**Ordered by risk and by what has to come last, not by a build dependency — +there is no longer one.** While the plan was to regenerate `JuliaHubK8sApi`, it +came first because everything linked against it. Removing it instead inverts +that: a `Project.toml` line cannot come out until the references above it are +gone, so it is the *tail* of every repo's work rather than the head, and it is +collected in one section at the end. What is left to order is risk. + +- **(1) first** because it is the one a green Kuber suite does not clear, and the + one whose answer could change the others: if the reflector's loop cannot be + made to work against this branch's watch contract, that is worth knowing before + anything else is rewritten. +- **(2)–(4)** are largely independent of each other; take them in whatever order + suits, and note that JobLoops sits downstream of JuliaRun and K8sReflector, so + it is the natural last of the three. +- Everything but (2) is in the JuliaHub monorepo; `JuliaRun.jl` is its own + repository. +- **(5) last**, once nothing references the package — except its one question, + the `api_module` config key, which is worth *asking* early: it is deployment + config in a third repo and the answer may need someone else. + +**Three of these are silent and do not wait their turn.** They are defects, not +port steps, and one of them is broken today; see +[the last section](#what-will-and-will-not-announce-itself). + +### 1. `packages/K8sReflector` — highest risk, do it first + +Kuber's own green suite does **not** clear this one: G2's tests cover the +contract the reflector needs, not the reflector. Its loop is also the only place +in the stack that depends on watch semantics this branch changed outright, so an +answer here is worth having before the mechanical work starts. + +- [ ] `:216-245` — the loop wraps `Kuber.watch` in its own `while true` and + relies on `watch` *returning* on a long-poll timeout so it can re-establish + from its own tracked `resourceVersion`. Watches carry no overall deadline + here and do not return that way ([G2](#g2-caller-driven-re-establishment)) +- [ ] `:52-53` — reads `IoK8sApimachineryPkgApisMetaV1WatchEvent` and + `…MetaV1Status` off `c.apimodule`, which no longer exists ([C3](#c3-ctxapimodule-reach-through)) +- [ ] `:4` — `using OpenAPI.Clients: is_longpoll_timeout, is_request_interrupted` + → `Kuber.is_retryable`. `is_longpoll_timeout` has no successor and needs + none ([C2](#c2-openapiclients-does-not-exist-in-openapijl-10)) +- [ ] `:12` — `i.metadata.resourceVersion` → `resourceversion` ([C4](#c4-camelcase--lowercase-field-names)) +- [ ] Consider passing `resource_version=` when re-establishing: the events-only + form lists internally and discards the result, so anything created in that + window is never announced (`README.md`, and G5a's note) + +### 2. `JuliaRun.jl` — the bulk of it + +- [ ] `src/kubernetes/types.jl:8-12` and `src/metrics/kubernetesmetrics.jl:58-62` + — `KuberContext(K8sApi; long_polling_timeout=…, timeout=…)` → + `KuberContext()` plus `set_timeout` / `set_request_options` + ([C1a](#c1a-the-mechanism--cheap-because-the-architecture-is-already-plugin-shaped), [C6](#c6-kubercontext-timeout-kwargs)) +- [ ] `src/kubernetes/kubernetes.jl:52`, `src/metrics/kubernetesmetrics.jl:13` — + delete `const K8sApi = JuliaHubK8sApi`, and with it every `K8sApi.` prefix. + No `Kuber.register!` call is needed: there is no out-of-tree layer left to + register ([C1a](#c1a-the-mechanism--cheap-because-the-architecture-is-already-plugin-shaped)) +- [ ] `src/kubernetes/clustermgmt.jl:511-516`, `src/kubernetes/api.jl:1570-1576` + and `:1687-1692` — the three `isa` chains over a watch stream. + `Typedefs.*.WatchEvent` → `KuberEvent`; `Typedefs.EventsV1.Status` → + `kuber_kind(event) == "Status"`; `Typedefs.CoreV1.{Node,Pod,Service,…}` → + `kind_to_type(ctx, :Node)`, which resolves through the server's preferred + version instead of pinning it. The `kuber_obj(cm.ctx, event.object)` line + goes with them — `event.object` is already typed ([C1c](#c1c-what-the-port-costs-juliarun), [C3](#c3-ctxapimodule-reach-through)) +- [ ] `src/kubernetes/api.jl:220-248` (`Secret`, `ObjectMeta`) and `:264` + (`Status`) — construction, so name the type directly: + `kind_to_type` needs a context and these have none to hand ([C1c](#c1c-what-the-port-costs-juliarun)) +- [ ] `src/kubernetes/api.jl:1841-1843`, `src/kubernetes/clustermgmt.jl:20`, + `api.jl:1168` — `isa` on a plain model (`Quantity`, `Node`); either form + works, a direct type reference is one indirection fewer ([C1c](#c1c-what-the-port-costs-juliarun)) +- [ ] `src/kubernetes/api.jl:1040, 1053, 1065, 1529` and + `src/kubernetes/clustermgmt.jl:114-115` — `OpenAPI.Clients.ApiException` → + `Kuber.KuberException`; `ex.resp.data` → `ex.message` or `ex.response` ([C2](#c2-openapiclients-does-not-exist-in-openapijl-10)) +- [ ] 49 sites — `import OpenAPI.Clients: getpropertyat, haspropertyat` → + `import Kuber: …`. Same walk, `ABSENT`-aware ([C2](#c2-openapiclients-does-not-exist-in-openapijl-10)) +- [ ] The same 49 sites — camelCase path elements (`:loadBalancer`, `:nodeName`, + `:backoffLimit`) must be lowercased. Case is deliberately not folded, so + these fail rather than resolving quietly ([C4](#c4-camelcase--lowercase-field-names)) +- [ ] `src/kubernetes/clustermgmt.jl:186-194` — **silent.** `hasproperty` is true + for every field on 1.0, so `container_resource` returns `ABSENT` instead of + falling through to its default ([G12](#g12-resource-limits-are-an-open-struct)) +- [ ] `src/kubernetes/clustermgmt.jl:281-285` — `keys(res)` / `res["cpu"]` on + `ResourceRequirements.limits`, which is an open struct now: `kuber_props` ([G12](#g12-resource-limits-are-an-open-struct)) +- [ ] `src/kubernetes/kubernetes.jl:20`, `types.jl:33`, `clustermgmt.jl:124`, + `api.jl:9, 16, 33, 151, 1767` — `OpenAPI.APIModel` has no successor; + 1.0 models share no supertype. Usually drop the constraint, since it only + separates a model from a `Symbol`/`Dict` ([C10](#c10-openapi-itself-not-just-openapiclients)) +- [ ] `src/kubernetes/provisioning.jl:68` — `OpenAPI.to_json(secret)` → + `Kuber.Runtime._encode(secret)`, which also removes the `_parse_json` + round-trip. **Not `JSON.json`**: that emits lowercase names and `"ABSENT"` + strings ([C10](#c10-openapi-itself-not-just-openapiclients)) +- [ ] `Project.toml` — Kuber to the branch (its `[sources]` OpenAPI pin has to be + repeated here, since Julia only honours `[sources]` in the top-level + project), `OpenAPI` compat off `0.2.5`, and the `JuliaHubK8sApi` dep and + `[sources]` entry out +- [ ] `src/kubernetes/{clustermgmt,api}.jl` — the `ABSENT` read-side audit ([C7](#c7-absent-audit--smaller-than-expected-but-not-zero)) +- [ ] Decide what happens to `src/metrics/kubernetesmetrics.jl`'s custom-metrics + half. Kuber does not ship `custom.metrics.k8s.io` ([C5](#c5-custom-metrics-captured-evaluated-not-shipped)), + and nothing calls these functions — `test/test_metrics.jl:104-176` is the + only caller and `runtests.jl` does not include it + +### 3. `services/JobLoops` + +- [ ] `.containerStatuses` (5 sites), `.restartCount`, `.nodeName` → lowercase ([C4](#c4-camelcase--lowercase-field-names)) +- [ ] `src/networkpolicy.jl:141-143` — **broken today, independently of this + port.** An object body under `application/json-patch+json`, which must be + an array of RFC 6902 operations; a real apiserver answers 422. Likely + intent is merge-patch ([C9](#c9-a-live-defect-in-jobloops-found-in-passing)) + +### 4. `JuliaRunPool`, `AccessControl`, `BillingService` + +- [ ] `packages/JuliaRunPool/…:135-136` — **silent.** `format: byte` decodes to + `Vector{UInt8}` already, so `String(base64decode(secret.data["x"]))` + decodes twice; the secret is then rewritten on every pass ([G12a](#g12a-secretdata-decodes-to-bytes-not-base64-text)) +- [ ] `packages/AccessControl/src/AccessControl.jl:77` — drop + `kwargs[:httplib] = OpenAPI.Clients.HTTPLib.HTTP` ([C2](#c2-openapiclients-does-not-exist-in-openapijl-10)) +- [ ] `services/BillingService/src/billing/main.jl:62` — drop + `httplib=OpenAPI.Clients.HTTPLib.HTTP` ([C2](#c2-openapiclients-does-not-exist-in-openapijl-10)) + +### 5. Remove the `JuliaHubK8sApi` dependency — last, everywhere at once + +**Decided 2026-08-15: the package is not regenerated, it goes.** Kuber's shipped +layer is a superset of what the consumers reach — `metrics.k8s.io/v1beta1` ships +in Kuber, no CRD group is used through Kuber at all, and `custom.metrics.k8s.io` +has no live caller ([C1b](#c1b-the-content--small-once-scoped-to-what-is-actually-used), +[C5](#c5-custom-metrics-captured-evaluated-not-shipped), and the +[usage audit](#appendix--juliahubk8sapi-group-version-usage-audit)). So this +section replaces "regenerate 11 MB" with "delete a dependency". + +- [ ] Drop the dep: `services/JobLoops/Project.toml`, + `packages/JuliaRunPool/Project.toml`, `services/common_dependencies.jl`, + `packages/sources.toml`, `services/JobLoops/spec.toml`, and JuliaRun's own + `Project.toml` +- [ ] `services/JobLoops/src/kuberutils.jl` — + `using JuliaHubK8sApi.Kubernetes: IoK8sApiCoreV1PodCondition` → + `Kuber.ApiImpl.K8sV1.IoK8sApiCoreV1PodCondition`. A direct generated-type + import, and the only one found outside JuliaRun +- [ ] `services/JobLoops/src/k8s_job_pod_monitoring.jl` — `using JuliaHubK8sApi` +- [ ] **Check `"api_module": "JuliaHubRun.JuliaHubK8sApi"`** in + `common/config/config_juliarun.json` and in `JuliaHubInfra.jl`'s + `src/ansible/roles/juliateam/templates/juliarun.json.j2`. The key is dead + once `KuberContext(apimodule)` is gone, but an org-wide code search found + no reader — so establish whether something resolves it by name and would + fail, or whether it is already vestigial. **Deployment config, in a third + repo, and outside the two trees this document surveyed** +- [ ] `packages/ImageAPICommon/src/sha.jl` — a stale type name in a comment only +- [ ] Archive or deprecate the repository once nothing depends on it + +### What will and will not announce itself + +Most of the above is loud: a missing symbol, a `MethodError`, a `type has no +field`, all at load time or on the first call. **Three are silent**, and they are +the ones worth reviewing rather than waiting for: + +| Site | What happens | | +|---|---|---| +| `JuliaRunPool …:135-136` | secret compared against a double-decoded value, so it never matches and is rewritten forever | [G12a](#g12a-secretdata-decodes-to-bytes-not-base64-text) | +| `clustermgmt.jl:186-194` | `container_resource` returns `ABSENT` rather than its default | [G12](#g12-resource-limits-are-an-open-struct) | +| `networkpolicy.jl:141-143` | 422 on a path that may simply never be taken — `needs_update` only fires when the `version` label differs | [C9](#c9-a-live-defect-in-jobloops-found-in-passing) | + +--- + +## Suggested order + +1. ~~**C1a** — the registration mechanism.~~ **Done** — `src/register.jl`, + `test/register.jl`, documented in `README.md`. +2. ~~**G1** — the one silent-correctness item.~~ **Done** — the pump re-lists on + expiry and delivers a resync frame; `test/watch_recovery.jl`. +3. ~~**G15 / C2** — export an exception-classification helper.~~ **Done** — + `Kuber.is_retryable`; porting the consumer call sites is the remaining half + of C2. +4. ~~**C1b / C5**~~ — **done**: `fetch_specs.sh --from-cluster` exists, + `metrics.k8s.io/v1beta1` is captured, shipped and live-tested, and the + custom-metrics helpers are reimplemented. `custom.metrics.k8s.io/v1beta1` was + captured on 2026-08-15 and deliberately **not** shipped — no caller, no + operation GVKs, a three-variable metric path. C5 has the evidence and + `gen/openapi_v1/reference-captures/` has the document. Between them those two + decisions emptied `JuliaHubK8sApi` of anything it still contributed, so on + 2026-08-15 C1b turned from "regenerate it" into "remove it". +5. Widen the live suite, cheapest first: ~~**G13**~~, ~~**G4**~~, ~~**G6**~~, + ~~**G9/G10/G11**~~, ~~**G2**~~ and ~~**G3**~~ all done. **G16** is done too, + and turned into [C8](#c8-json-patches-did-not-encode-at-all); **G10** turned + into [G17](#g17-resource_version-is-accepted-and-ignored-on-non-watch-reads), + which needs a decision before it can be scheduled. + + **The watch-contract cluster — the one flagged highest-risk — is now closed** + (G1–G4 all ticked), except for the reflector port under G2 and G5. What is + left in Part 2 is the cheap remainder: ~~G7~~, ~~G8~~, ~~G14~~ and + ~~G12/G12a~~ done; G5 was split on 2026-08-15 into ~~**G5a**~~, now covered by + `long_lived_watch`, and **G5b**, a documented manual probe — the hour of + waiting was never the mechanism, and a server-initiated close is producible in + seconds. + Both G12 items produced consumer fixes rather than Kuber ones, and + G12's audit is what surfaced the `getpropertyat`/`haspropertyat` gap in + [C2](#c2-openapiclients-does-not-exist-in-openapijl-10). +6. **C1d** deferred until a CRD actually needs addressing. + +7. ~~**G18**~~ and ~~**G17**~~ done. One regeneration carried G18 and G17's + `list` half; G17's `get` half followed after G19/G20, as patch rule §8. The + sequencing was the point: §8's natural failure is a slow 504, which was worth + nothing while `max_tries=1` still meant ten requests. +8. ~~**G19** and **G20**~~ done together, which was the only way they made + sense: with HTTP.jl's layer off, Kuber's status list became the whole story, + so 429 had to join it. Settling them is what unblocked G17's `get` half. + +**Everything in Part 2 is now closed except G12/G12a**, which are consumer-side +audits rather than Kuber changes. G5a landed on 2026-08-15 — the hour-long test +turned out to be a twelve-second one — and G5b stays open by design, as a manual +probe. What remains is Part 1: the C-items, **all of which are now work in the +consumer repos** — +C1b/C5 was the last one needing anything of Kuber, and its capture is done and +its decision recorded. + +Four of the five widening items produced a finding rather than just coverage +(C8, G12a, G17, G18), which is the argument for continuing to spend on the live +suite: what it buys is not the assertions, it is what writing them turns up. +G6 is the counter-example and a useful one — seven new kinds, no new patch rule. +G18 is the sharpest case: it was found by an assertion too obvious to be worth +writing, in a testset whose stated purpose was to check something else. + +--- + +## Appendix — JuliaHubK8sApi group-version usage audit + +Surveyed 2026-08-13 against `JuliaHubK8sApi` 0.2.3, `JuliaRun.jl` and the JuliaHub +monorepo. It ships **43** group versions; this branch's **17** are a strict subset, +so it adds **26**. Of those 26: + +| Extra group version | Used through Kuber? | Evidence | +|---|---|---| +| `metrics.k8s.io/v1beta1` | **yes** | `Typedefs.MetricsV1beta1` ×4; `:NodeMetrics`, `:PodMetrics` | +| `custom.metrics.k8s.io/v1beta1` | **yes** | `Typedefs.CustomMetricsV1beta1` ×2; `:MetricValue` | +| `custom.metrics.k8s.io/v1beta2` | **needs a runtime check** | never named; `:MetricValue` resolves by server preference | +| the other 23 | **no** | listed below | + +Unused: `admissionregistration.k8s.io/v1`, `authentication.k8s.io/v1`, +`authorization.k8s.io/v1`, `cluster.redpanda.com/v1alpha1`, +`crd.k8s.amazonaws.com/v1alpha1`, `elbv2.k8s.aws/v1alpha1`, +`elbv2.k8s.aws/v1beta1`, `flowcontrol.apiserver.k8s.io/v1`, +`flowcontrol.apiserver.k8s.io/v1beta3`, `helm.cattle.io/v1`, +`helm.toolkit.fluxcd.io/v2beta1`, `k3s.cattle.io/v1`, +`karpenter.k8s.aws/v1alpha1`, `karpenter.sh/v1alpha5`, `monitoring.coreos.com/v1`, +`monitoring.grafana.com/v1alpha1`, `networking.k8s.aws/v1alpha1`, +`redpanda.vectorized.io/v1alpha1`, `source.toolkit.fluxcd.io/v1` + `/v1beta1` + +`/v1beta2`, `vpcresources.k8s.aws/v1alpha1` + `/v1beta1`. + +**No CRD group is used through Kuber.** + +### How the blind spots were closed + +A grep for type names alone would have been wrong three times over: + +- **Dynamic kinds.** `JuliaRun/src/kubernetes/api.jl:522,601,855,867` do + `put!(cm, Symbol(job["kind"]), job)`, so the kind set is not statically obvious. + Every `"kind"` assigned under `src/kubernetes/` was traced: RoleBinding, + ClusterRole, ServiceAccount, DaemonSet, Namespace, ResourceQuota, CronJob, + Service, plus `"$kind"` interpolations in the job and service templates. All core + v1 / apps/v1 / batch/v1 / rbac — inside this branch's 17. +- **The monitoring CRDs are a red herring.** JuliaRun's tree contains + `ServiceMonitor` (12), `PrometheusRule`, `Prometheus`, `Alertmanager` and + `ThanosRuler`, but they live under + `scripts/local/compute/metrics/prometheus/manifests/` and are applied by + `kubectl create -f manifests/` in `deploy.sh` — never through Kuber. +- **`karpenter.k8s.aws`** appears once in JuliaRun, as a node *label string* + (`src/kubernetes/api.jl:2`), not a CRD type. + +Corroborating signals: every direct generated-type reference across both repos is +upstream (`IoK8sApiAppsV1Deployment` ×12, `…MetaV1ObjectMeta` ×10, +`…DeploymentStatus`/`List`/`Spec`, `IoK8sApiCoreV1Pod`, `…MetaV1WatchEvent`, +`…MetaV1Status`, `IoK8sApiCoreV1Namespace`); the `Typedefs` submodules JuliaRun +references are `CoreV1` (17), `MetricsV1beta1` (4), `EventsV1` (4), +`CustomMetricsV1beta1` (2), `MetaV1` (1); and `apiVersion` literals in monorepo +`.jl` files are `v1` (5), `networking.k8s.io/v1` (3), `apps/v1` (1). + +`EventsV1` is only reached for its `Status` alias — an artifact of the old alias +layout rather than use of the events group, which is upstream anyway. + +### Caveats + +- Static analysis of two trees. `JuliaHubK8sApi` is a shared package and may have + consumers outside them. +- `custom.metrics.k8s.io/v1beta2` needs a runtime check, not a grep. +- Re-run this audit before regenerating: it is a point-in-time snapshot. diff --git a/OpenAPIv1RewriteNotes.md b/OpenAPIv1RewriteNotes.md new file mode 100644 index 00000000..edde7800 --- /dev/null +++ b/OpenAPIv1RewriteNotes.md @@ -0,0 +1,387 @@ +# Kuber.jl on OpenAPI.jl 1.0 — evaluation findings and rewrite notes + +**Status: reference notes, written 2026-08-10, updated 2026-08-12 for head +`1ff9ba8`.** Findings from evaluating +[JuliaComputing/OpenAPI.jl#103](https://github.com/JuliaComputing/OpenAPI.jl/pull/103) +("Pure-julia OpenAPI internals rewrite"), specifically from the angle of +rewriting Kuber.jl against it. Everything below was verified hands-on: against +the legacy petstore test servers, against synthetic streaming servers, and +against a live k3s v1.35 cluster (via `kubectl proxy`). Companion prototype +files live in [`gen/openapi_v1_prototype/`](gen/openapi_v1_prototype/). + +Three evaluation rounds so far: `bd96d53` (first full round), `c2a5244` +(re-verified everything after the tolerant-decode fix, the shared-runtime +refactor, and generation precompilation landed), and `1ff9ba8` (2026-08-12). +Every issue we raised upstream is now **fixed and verified live**, including +the watch-codec media-matching nuance from section 2 — raised on the PR +2026-08-12, fixed the same day in `1ff9ba8` (stream codecs fall back to the +`accept=` media type when the received Content-Type matches no registration). +At `1ff9ba8` the PR's own suite passes 700/700 (27 testsets), and generated +module output is byte-identical to `c2a5244` — the fix is runtime-side only, +no regeneration needed. + +--- + +## 1. What OpenAPI.jl 1.0 is, in one paragraph + +The PR replaces the 0.2.x runtime-library model with a generator. There is no +`OpenAPI.Clients` / `OpenAPI.Servers` runtime anymore and no compatibility shims: +`OpenAPI.client(spec; name, path)` reads an OAS 3.0/3.1/3.2 document (JSON or YAML) +and emits a **single Julia module** containing the document's models, typed +operations, and embedded JSON Schemas for boundary validation. Constraints that +matter for Kuber: Julia **1.11+**, HTTP.jl **2.x only**, JSON.jl **1.7+**; the +`openapi-generator` (Java) toolchain and Kuber's current generated `src/ApiImpl` +code stop working entirely. Generated code is precompile- and +JuliaC-`--trim`-friendly (the PR tests this), which suits shipped products. + +Since `ae201a7` (BREAKING for generated-code shape), generated modules no longer +carry a pasted ~2,000-line runtime: they **import `OpenAPI.Runtime`** and contain +only their own spec data (`_SPEC`), models, and operations. A 4-operation spec +now emits ~190 lines (was ~2,400); petstore v3 dropped 165→99 KiB. The HTTP +transport itself lives in the package's HTTP extension (`_request` / +`_stream_request` seams), and TimeZones support moved to an +`OpenAPITimeZonesExt` weakdep extension — `datetime = :zoned` clients need +`using TimeZones` in the consumer environment. Consequence for Kuber: baked +modules are **version-coupled to the OpenAPI package** (they import internal +`Runtime._decode`/`_encode` names), so pin OpenAPI's version alongside the baked +matrix and regenerate on upgrades. `c2a5244` precompiles the generation pipeline: +k8s core v1 generation dropped from ~31s to ~7s cold / ~3s warm per document. + +As of `bd96d53` the four gaps found in the first evaluation round are fixed and +were re-verified (again at `c2a5244`): + +- undocumented 2xx statuses succeed (empty body → `nothing`, payload → raw bytes) + instead of throwing; +- a missing/blank response Content-Type falls back to decoding by the documented + media type (`UnexpectedContentType` only remains for genuinely ambiguous cases); +- `datetime = :zoned` generation option maps `date-time` to + `TimeZones.ZonedDateTime` with offsets preserved on the wire (default `:utc` maps + to `Dates.DateTime`, offsets normalized to UTC); +- streaming exists: every operation accepts `stream_to = Channel(n)`, returns at + the response head, and a producer task decodes items onto the channel. + +The streaming implementation reproduces the semantics Kuber depends on from the +legacy fixes (OpenAPI.jl PRs 97/98/100/101/102): incremental small-chunk delivery +(verified 0.0s first-item latency after JIT warmup while the server stalls 4s +before the next item), `close(channel)` aborts the transfer (server observes the +connection close in ~0.2–0.4s; a 250ms watcher plus explicit stream teardown), +streaming defaults to HTTP/1.1. One deliberate difference: a **truncated final +JSON document closes the channel with a `DecodeError`** instead of ending +silently. Kuber's watch loop must expect close-with-error, not just clean close — +today `simpleapi.jl` treats stream end leniently; the rewrite should catch the +channel exception and decide retry-vs-surface (`k8s_retry` semantics). + +## 2. Upstream status (as of `1ff9ba8`, all raised issues fixed) + +Both gaps raised after round one are **fixed** in `fd4558c` and verified live: + +1. **`Client(validate_responses=false)` now reaches nested model decoding.** + Verified against the live cluster with the *pristine* (unpatched) k8s spec: a + tolerant client decodes real pod lists — all 170 null `lastProbeTime`s on our + cluster arrive as `nothing` — while a strict client still rejects them, as it + should. Semantics: unknown response properties ignored, explicit `null` on an + optional non-nullable property → `nothing`, missing optional → `ABSENT`; + values that can't fit the Julia type can still raise `DecodeError` (e.g. a + missing *required* field remains an error even when tolerant). +2. **Streaming consults `codec!` custom decoders per framed item**, with + parameterized-media registration intended to scope the override + (`codec!(client, "application/json;stream=watch"; decode=...)`). + + **The media-matching nuance is fixed in `1ff9ba8`** (raised on the PR + 2026-08-12, fixed the same day). Background: codecs are matched against the + *received* Content-Type, and real k8s always replies plain + `Content-Type: application/json` — even when you Accept the `stream=watch` + variant — so at `c2a5244` the parameterized registration never fired against + a real cluster. Now, when no registration matches the received media type, + streaming calls fall back to the media type the call requested via the + `accept=` keyword (`_stream_codec_media` in `src/runtime.jl`). Verified live + at `1ff9ba8` on the pristine spec, all on **one shared client**: + + ```julia + K.codec!(client, "application/json;stream=watch"; + decode = (bytes, _) -> JSON.parse(String(bytes))) + K.listcorev1namespacedconfigmap(ns; client, watch = true, + accept = "application/json;stream=watch", stream_to = events) + ``` + + The codec fires for exactly the calls that pass that `accept`; buffered + calls on the same client still decode typed models. The previous + workaround (plain-`application/json` codec on a dedicated watch-only + client) still works and remains the fallback for pre-`1ff9ba8` heads. + +## 3. How Kuber works today (what the rewrite must replace) + +References are to Kuber.jl `main` at `0d91a51`. + +- **Generation at build time** (`gen/`): openapi-generator emits one module per + API group+version from a pinned k8s spec into `src/ApiImpl`. Nothing is fetched + from the server's OpenAPI endpoints at runtime — "auto discovery" means + *group/version discovery*, not spec discovery. +- **Runtime discovery** (`src/helpers.jl:510` `set_api_versions!`): calls the k8s + discovery endpoints through the pre-generated client — `GET /api` + (`fetch_core_version`, `helpers.jl:452`) and `GET /apis` + (`get_a_p_i_versions`, `helpers.jl:397`) — then maps each server-reported + group/version to a shipped module by symbol lookup + (`getfield(apimodule(ctx), Symbol("Core"*camel(vers)*"Api"))`), tolerating gaps. + `build_model_api_map` then maps model names → API version for the `get`/`list` + symbol API. +- **Dynamic return typing** — the load-bearing legacy hook. The client is built + with `get_return_type = kuber_type` (`helpers.jl:110-112`); `kuber_type` + (`helpers.jl:227-257`) peeks at each response payload's `kind`/`apiVersion` to + pick the Julia type, and recognizes watch frames (`type`+`object` keys → + `WatchEvent`). This is what makes Kuber immune to the k8s spec declaring the + wrong response schema — the type comes from the payload, not the spec. **The new + OpenAPI has no equivalent hook**; section 5 explains why it's no longer needed. +- **Watch** (`src/simpleapi.jl:30-51`, `list(...; watch=true)` at `:55`): legacy + channel streaming, `KuberEventStream`, per-chunk decoding through the + `get_return_type` hook. +- **`int-or-string`** (`helpers.jl:530-531`): extends legacy + `OpenAPI.val_format(::Val{Symbol("int-or-string")})`. Not needed in the new + world: k8s OpenAPI v3 declares `IntOrString` as a proper + `oneOf: [integer, string]`, which the new planner maps to a real union wrapper + type. (The `val_format` extension point no longer exists anyway.) +- Other legacy touchpoints that disappear: `(result, http_resp)` tuple returns and + `check_api_response`; `OpenAPI.Clients.Client(...; client_kwargs...)` and + `client.headers` mutation; `Downloads.Response` header handling + (`helpers.jl:237-242`); `kuber_obj`'s `convert(T, ::Dict)` construction. + +## 4. Live-cluster findings (k3s v1.35, spec `api/v1` from kubernetes master) + +Tested with a client generated from the **pristine** k8s core v1 OpenAPI v3 +document (2.1 MB, 113 paths). Generation itself works in **strict mode** — the +PR's `ac0689d` fixed the parameterized-media-key rejection that the k8s documents +otherwise trip (`application/json` vs `application/json;stream=watch` on every +list operation). + +1. **Pod lists are undecodable with the pristine spec.** The spec declares + `io.k8s.apimachinery.pkg.apis.meta.v1.Time` as a non-nullable `date-time` + string; the live API returns `"lastProbeTime": null` (on our cluster: all 165 + pod conditions had it). Model-level validation throws `SchemaValidationError`, + and per gap `#1` above no flag avoids it. +2. **Watch frames don't match the declared schema.** k8s declares the *List* type + for the `application/json;stream=watch` media entry, but the wire carries + `WatchEvent` objects (`{"type": "ADDED", "object": {...}}`). Per-item streaming + decode fails. +3. **Content negotiation cannot fix `#2` — verified and important.** k8s replies + `Content-Type: application/json` regardless of the `Accept` header (confirmed + with curl, with and without `Accept: application/json;stream=watch`). So + patching the `;stream=watch` media entry is unreachable: media selection is + driven by the response Content-Type, which always matches the plain + `application/json` (List-typed) entry. The deeper truth: a single k8s list + operation returns two different wire shapes depending on the `?watch=` query + parameter, which OpenAPI cannot express on one operation. (Since `1ff9ba8` + the *decode* side of this is solved without touching the spec: an + accept-scoped `codec!` override, see section 2. The spec statement is still + wrong; the codec is the sanctioned escape hatch for it.) +4. **Version-skew safety is good.** k8s schemas don't close their objects, so + generated models park unknown JSON keys in `additional_properties::Dict{String,Any}` + without error (verified by decoding a payload with an invented future field). + A baked client for k8s 1.N tolerates *added* fields from a 1.N+2 server; only + contract *violations* (nulls, shape changes) bite, and GA APIs rarely do that. + +## 5. The bake pipeline (prototyped, all green) + +Design decision this validates: **runtime spec fetching/generation is out** for a +shipped product (measured: ~31s generation + ~6.5s load for core v1 alone, times +~30 group documents, `eval`'d with no precompilation). Instead: a small matrix of +**baked, spec-patched, pre-generated modules**, switched at connect time. + +### Patch step + +[`gen/openapi_v1_prototype/patch_k8s_spec.jq`](gen/openapi_v1_prototype/patch_k8s_spec.jq), +applied to each pristine k8s group document before generation: + +- `meta.v1.Time` **and `meta.v1.MicroTime`** get `nullable: true` (OAS 3.0 + `nullable` sibling — honored in strict mode because the schema declares + `type: string`). MicroTime was found by the all-groups sweep: Events carry + `eventTime: null` (core v1 and events.k8s.io/v1 both); +- **every array-typed property gets `nullable: true`**: Go marshals nil slices + as JSON `null`, so any array — even spec-required ones — can arrive null. + Found live: `CSINodeSpec.drivers: null` on storage.k8s.io/v1. The blanket + rule kills the whole class instead of chasing fields one at a time; +- every dedicated `/watch/` path's `application/json` response schema is rewritten + to `WatchEvent`. The `/watch/` paths are marked deprecated by k8s but remain + served, are watch-only (so the patch is semantically honest), and exist in the + document as separate operations — 70 of them in core v1. **Watching goes through + these operations**, not through `list(...; watch=true)`, because of finding `#3`. + If the `/watch/` paths are ever removed upstream, the fallback is splitting each + list operation into two in the patch step (one per `?watch=` shape). + +Expect this patch list to grow as the fleet finds more spec lies; that's the +point of owning the patch step. The 2026-08-12 all-groups sweep (below) found +and fixed two new classes (MicroTime, nil-slice arrays) on the first pass — +the guarded patch (`select(has(...))` on every rule) applies cleanly to +documents that lack the schema or have no `/watch/` paths, including +CRD-backed group documents. + +### All-groups sweep (2026-08-12, at `1ff9ba8`) + +All **27** OpenAPI v3 group documents served by the k3s v1.35 cluster — +including CRD-backed groups (`helm.cattle.io/v1`, `k3s.cattle.io/v1`), Gateway +API (`gateway.networking.k8s.io/v1` + `v1beta1`), and the aggregated +`metrics.k8s.io/v1beta1` — swept through patch → strict generate → load → +live calls (`smoke_groups.jl`): + +- **27/27 patch cleanly** (guarded jq rules; CRD groups have no `/watch/` + paths, which is fine — CRD watch goes through `list(...; watch=true)` + + accept-scoped codec); +- **27/27 generate in strict mode**, ~39s and ~30 MiB total (core v1 6.7 MiB / + 11s is the largest; most groups are 0.2–1.8 MiB and take under a second); +- **all 27 modules load together** in one session (~29s uncompiled, includes + JIT — precompilation absorbs this in a real package); +- **74/74 zero-positional-arg list operations** across all groups decode + strictly against the live cluster (854 items) — after the MicroTime and + array-nullable patch rules were added; before them 71/74 (the three + failures are what motivated the rules); +- typed watch on apps/v1 via the patched `/watch/` path delivers + `WatchEvent`s with second-stage decode to `IoK8sApiAppsV1Deployment` — 5/5. + +### Generation and results + +```sh +jq -f patch_k8s_spec.jq api__v1_openapi.json > api__v1_patched.json +julia -e 'using OpenAPI, HTTP; OpenAPI.client("api__v1_patched.json"; name="K8sCoreV1", path="K8sCoreV1.jl")' +``` + +~7s cold / ~3s warm per group document as of `c2a5244` (was ~31s at `bd96d53`); +core v1 emits a ~6.7 MiB module (dominated by models and embedded schema data — +the shared-runtime refactor shrinks small specs dramatically but k8s-sized ones +only modestly) that loads in ~5–6.5s uncompiled (precompilation absorbs this in +a real package). Against the live cluster, with **full validation on and strict +generation**, the prototype test +([`gen/openapi_v1_prototype/k8sbaked.jl`](gen/openapi_v1_prototype/k8sbaked.jl)) +passes 8/8 — verified at both `bd96d53` and `c2a5244`: + +- pod list across all namespaces decodes; all 165 null `lastProbeTime`s arrive as + `nothing`; +- `watchcorev1namespacedconfigmaplist(ns; resourceversion=..., stream_to=events)` + delivers typed `WatchEvent`s live — an ADDED (configmap created mid-watch via + kubectl) and a DELETED on the same stream; +- `close(events)` cancels the watch cleanly. + +### The `kuber_type` replacement + +`WatchEvent.object` is k8s's `RawExtension`, generated as an open struct whose +payload sits in `.additional_properties::Dict{String,Any}`. The second-stage +decode into a typed model is one call, verified working: + +```julia +cm = K8sCoreV1._decode(K8sCoreV1.IoK8sApiCoreV1ConfigMap, event.object.additional_properties) +``` + +So `kuber_type`'s payload sniffing reduces to a per-module lookup table +`(kind, apiVersion) → generated type` feeding `_decode`. With patched specs the +declared schemas are finally *true*, so strict typed decoding does what the hook +used to fake. (Note `_decode` is runtime-internal — since `ae201a7` it lives in +`OpenAPI.Runtime` and generated modules import + extend it; either use it +knowingly or ask upstream for a public `decode(Module, T, json)` entry point.) + +### The patch-free route (upgraded at `1ff9ba8`, verified live) + +With the accept-scoped codec fix (section 2), the **pristine spec** is now +fully workable end to end — no jq patch step at all — verified 11/11 live at +`1ff9ba8` (`k8spristine_v3.jl`): + +- lists/gets: a tolerant client (`validate_responses = false`) decodes real pod + lists on the pristine spec into typed models (verified: 34 pods, 170 null + Times → `nothing`); a strict client still rejects them, as the spec says it + must; +- watch: on the **same shared client**, register + `codec!(client, "application/json;stream=watch"; decode = (bytes, _) -> JSON.parse(String(bytes)))` + and pass `accept = "application/json;stream=watch"` on the watch calls. Raw + JSON event dicts stream out (verified live: ADDED observed, buffered calls on + the same client unaffected), and the kind→type table second-stage decodes: + `_decode(K.IoK8sApiCoreV1ConfigMap, ev["object"], false)` — verified. + This uses the regular list operations (`watch = true`), *not* the deprecated + `/watch/` paths. + +**Choosing between the two routes.** Both are live-verified at `1ff9ba8`: + +| | Patched bake (section above) | Patch-free (this section) | +| --- | --- | --- | +| Spec patch step | jq: nullable Time + `/watch/`→WatchEvent | none | +| Response validation | strict, on | off (`validate_responses = false`) | +| Watch operations | dedicated `/watch/` paths (deprecated in k8s, still served) | regular list ops with `watch=true` (not deprecated) | +| Watch item type | typed `WatchEvent` directly | raw JSON dict + second-stage decode | +| Upstream dependency | none beyond `fd4558c` | needs `1ff9ba8`+ | + +A middle option worth considering for the rewrite: patch **only** +`meta.v1.Time` nullable (one jq line — keeps strict validation on all buffered +calls) and use the accept-scoped codec for watch. That drops the largest and +most fragile part of the patch (70 `/watch/` path rewrites), stays off +deprecated paths, and keeps validation everywhere except inside watch frames — +where the second-stage `_decode` re-establishes typing anyway. + +## 6. Recommended rewrite architecture + +1. **Spec matrix, checked in**: per supported k8s minor (e.g. 1.33/1.34/1.35), the + per-group OpenAPI v3 documents for the groups Kuber actually surfaces (core, + apps, batch, rbac, networking, …) — vendored from `kubernetes/kubernetes` + release tags, or captured from reference clusters via + `kubectl get --raw /openapi/v3/`. +2. **Patch + generate at build time** (replaces today's `gen/` openapi-generator + flow): one generated module per (group, minor). If image size becomes a + concern, split per-minor into sub-packages/extensions so deployments carry only + what they need. +3. **Connect-time switch**: `GET /version` → server minor → nearest baked minor at + or below it (simpler and cheaper than today's per-group probing). Keep the + `/apis` probe only for what it uniquely answers: which groups a managed cluster + has disabled. Skew tolerance (finding `#4`) is what lets "a few" minors cover a + fleet. +4. **Facade unchanged**: keep the `KuberContext` + symbol-based `get`/`list`/ + `watch`/`put!`/`delete!` user API; the apis dict maps (group, version) → + generated module, `modelapi` becomes the kind→type tables from section 5. +5. **Watch**: two verified routes — dedicated `/watch/` operations on the + patched spec (typed `WatchEvent`s directly), or `list(...; watch = true)` + with an accept-scoped `codec!` + second-stage decode (section 5, needs + `1ff9ba8`+; avoids deprecated paths and the 70-path patch). Either way, + `stream_to::Channel` wrapped in the existing `KuberEventStream`/retry + machinery, updated for close-with-error semantics (section 1). Given the + preference to minimize spec patching, the accept-scoped codec route with a + Time-only patch is the recommended starting point. +6. **Rewrite scope**: essentially all of `src/helpers.jl` and the call layer of + `src/simpleapi.jl` (returns are now value-or-throw `ApiError`; client + construction, headers, credentials all per generated module). `test/` server + fixtures based on legacy `OpenAPI.Servers` need regenerating with + `OpenAPI.server` (the new PR generates HTTP.Router servers with a `register!` + contract deliberately matching the 0.2.x shape). + +## 7. Preconditions before starting the rewrite + +- [x] ~~The `validate_responses` model-decode gap~~ — fixed in `fd4558c`, + verified live at `c2a5244`. Re-confirm it survives into the merged/tagged + version. +- [x] ~~Raise the watch-codec media-matching nuance (section 2.2) upstream~~ — + raised on the PR 2026-08-12 + ([comment](https://github.com/JuliaComputing/OpenAPI.jl/pull/103#issuecomment-5264410229)), + fixed the same day in `1ff9ba8`, verified live 11/11. +- [ ] PR #103 merged and tagged; pin the OpenAPI version the baked modules were + generated with (they import `OpenAPI.Runtime` internals — regenerate on + OpenAPI upgrades). +- [ ] Product runtime environments on Julia ≥ 1.11, HTTP.jl 2.x, JSON.jl ≥ 1.7 + (hard requirements of the new OpenAPI). +- [ ] Decide zoned vs UTC date-times per module (`datetime = :zoned` now needs + `using TimeZones` in the consumer env via the `OpenAPITimeZonesExt` + extension; `:utc` is trim-friendlier — k8s timestamps are UTC anyway, so + `:utc` is likely right for Kuber). +- [x] ~~Sweep the non-core k8s group documents through patch+generate~~ — done + 2026-08-12 at `1ff9ba8`: all 27 cluster-served group documents + (incl. CRD-backed and aggregated APIs) patch, generate strict, load, and + pass live list/watch calls; see the all-groups sweep in section 5. + Two new patch rules came out of it (MicroTime, array-nullable). +- [ ] Re-run `gen/openapi_v1_prototype/k8sbaked.jl` and + `gen/openapi_v1_prototype/k8spristine_v3.jl` against the then-current PR + head and a real cluster. + +## 8. Prototype artifacts + +| File | What it is | +| --- | --- | +| `gen/openapi_v1_prototype/patch_k8s_spec.jq` | The spec patch step (Time/MicroTime nullable + arrays nullable + `/watch/` → WatchEvent), guarded so it applies to every group document incl. CRD-backed ones | +| `gen/openapi_v1_prototype/smoke_groups.jl` | The all-groups sweep: loads all 27 generated modules, strict-lists every cluster/all-namespaces resource, typed watch on apps/v1 — needs the 27 modules generated into `groups/` per the README | +| `gen/openapi_v1_prototype/k8sbaked.jl` | Live-cluster test: pod list, live watch (ADDED+DELETED), cancel — 8/8 at `bd96d53`, `c2a5244`, and `1ff9ba8` | +| `gen/openapi_v1_prototype/k8spristine_v3.jl` | Live-cluster test of the *unpatched-spec* route: strict-vs-tolerant pod list, watch-codec media matching (parameterized key without `accept=` doesn't fire; with `accept=` it fires on a shared client since `1ff9ba8`; plain-json codec on a dedicated client as pre-`1ff9ba8` fallback) — 11/11 at `1ff9ba8` | +| `gen/openapi_v1_prototype/README.md` | How to re-run the prototype end to end | + +The pristine/patched spec snapshots and the 6.6 MiB generated module are not +checked in — they regenerate in under a minute from the commands in the README. diff --git a/OpenAPIv1TrialBranchPlan.md b/OpenAPIv1TrialBranchPlan.md new file mode 100644 index 00000000..37779fa8 --- /dev/null +++ b/OpenAPIv1TrialBranchPlan.md @@ -0,0 +1,630 @@ +# Kuber.jl on OpenAPI.jl 1.0 — trial branch plan and instructions + +> **This plan has been implemented. Read +> [`OpenAPIv1TrialResults.md`](OpenAPIv1TrialResults.md) alongside it — that +> file records what the branch actually does and is current where the two +> disagree.** Implementation and measurement contradicted the plan in five +> places, all documented there: the patch list grew from three rules to five, +> `OPS` is keyed by module (§2.4's 3-tuple cannot express two shipped versions of +> one kind), the `isopen(stream)` retry guard of §4.3 left the retry path +> entirely (the watch call returns at the response head, so it is never the +> in-flight call), and 410 Gone is an in-stream `ERROR` event rather than an +> `ApiError` (§4.3, §5.3). + +**Status: implementation plan, written 2026-08-13.** Companion to +[`OpenAPIv1RewriteNotes.md`](OpenAPIv1RewriteNotes.md) (the evaluation findings) +and [`gen/openapi_v1_prototype/`](gen/openapi_v1_prototype/) (runnable +prototypes every design decision below was verified against). This document is +the step-by-step guide for building a **trial branch** of Kuber.jl fully +generated with the new OpenAPI.jl generator, before OpenAPI PR 103 is merged. + +## 0. Readiness verdict + +**Yes — everything the trial needs is verified working at PR head `1ff9ba8`.** +All issues raised across four evaluation rounds are fixed upstream and verified +live; all 27 k8s group documents generate in strict mode and decode live +cluster payloads; watch, tolerant decode, second-stage typed decode, retries +semantics, and the patch pipeline are all proven. The remaining risk is churn: +the PR is unmerged, generated modules import `OpenAPI.Runtime` internals, and a +future head can change generated-code shape (it did once, at `ae201a7`). That +is why this is a trial branch pinned to a commit, not a release. + +### Decisions locked in for the trial + +| Decision | Choice | Why | +| --- | --- | --- | +| OpenAPI.jl version | pin to `quinnj/OpenAPI.jl` branch `codex/production-rewrite`, commit `1ff9ba8dacf5857f0e712d26cc16e6a67bbdc46a` (package version 1.0.0, same UUID `d5e62ea6-...`) | accept-scoped stream codecs land here; everything verified at this head | +| Julia / HTTP / JSON | Julia ≥ 1.11, HTTP.jl 2.x, JSON.jl ≥ 1.7 | hard requirements of the new OpenAPI; user-approved | +| Datetimes | `datetime = :utc` (the generator default — pass nothing) | k8s timestamps are UTC; drops the TimeZones dep; trim-friendlier | +| Spec patching | **middle path**: nullable rules only (Time, MicroTime, all arrays); **no** `/watch/`-path rewriting | keeps strict validation on buffered calls; watch goes through non-deprecated list ops | +| Watch mechanism | `list(...; watch=true)` + accept-scoped `codec!` + second-stage typed decode | verified live 11/11; avoids deprecated `/watch/` paths | +| k8s minor for trial | one: whatever the reference/test cluster serves (k3s v1.35 during evaluation) | multi-minor bake matrix is a post-trial concern; the pipeline already supports it | +| Spec source | upstream `kubernetes/kubernetes` release tag (`api/openapi-spec/v3/`), not a local cluster | authoritative and reproducible; tag recorded in `SPECS_ORIGIN` (§2.1) | +| Generated code | pristine + patched specs **and** generated modules all checked into the branch (like today's `src/ApiImpl/api`) | reproducible CI, auditable fetch→patch→generate chain, no generation at install time | + +### Explicitly out of trial scope (defer) + +- Multi-minor spec matrix and connect-time minor switching (design is in the + notes §6; the trial hard-codes one minor). +- The JuliaHub custom-metrics API (`:MetricValue`, + `list_namespaced_custom_metrics`) — the models were hand-spliced into the old + swagger (`gen/spec/kuber.json`, `io.k8s.api.custom.metrics.v1beta1.*`); the + new pipeline needs an OpenAPI v3 document for + `custom.metrics.k8s.io/v1beta1`, captured from a JuliaHub cluster or + hand-written. Stub the two exported functions to throw a clear "not in + trial" error. +- CRD groups beyond what the test cluster serves (the pipeline handles them — + `helm.cattle.io` / `k3s.cattle.io` generated and passed live — but the JuliaHub + CRD set needs its docs captured from a JuliaHub reference cluster). +- Downstream-consumer compat shims. One behavioral change to socialize early: + **fields the old client returned as `nothing` when absent are now `ABSENT`**; + `nothing` now specifically means explicit JSON `null` (see §5.6). + +--- + +## 1. Branch and project setup + +```sh +cd ~/.julia/dev/Kuber +git checkout -b openapi-v1-trial +``` + +Replace `Project.toml` deps/compat (keep name/uuid/authors; bump version to +`0.8.0-dev` or similar so it's obviously the trial line): + +```toml +[deps] +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" +HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +OpenAPI = "d5e62ea6-ddf3-4d43-8e4c-ad5e6c8bfd7d" + +[sources] +OpenAPI = {url = "https://github.com/quinnj/OpenAPI.jl", rev = "1ff9ba8dacf5857f0e712d26cc16e6a67bbdc46a"} + +[compat] +HTTP = "2" +JSON = "1.7" +OpenAPI = "1" +julia = "1.11" +``` + +Notes: + +- **Dropped deps**: `Downloads` (no libcurl backend exists anymore), + `TimeZones` (`:utc` decision), `Random` (audit first — it is not used by + `helpers.jl`/`simpleapi.jl`; it may only be a leftover of the old generated + code, which is being deleted anyway). +- `HTTP` becomes a **direct** dep: it activates OpenAPI's HTTP extension + (without it there is no transport), and §4.2's discovery calls use it + directly. +- `[sources]` requires Julia ≥ 1.11 Pkg — fine, that's the floor anyway. When + the PR merges and tags, delete the `[sources]` block and set compat to the + tag; **regenerate all modules at that point** (generated output is only + guaranteed byte-stable within the pinned commit — it changed shape once + already at `ae201a7`). +- CI: the trial branch's CI matrix should drop Julia < 1.11. + +--- + +## 2. Generation pipeline (`gen/openapi_v1/`) + +Create `gen/openapi_v1/` with the pipeline below. Start from the prototype +files — `gen/openapi_v1_prototype/patch_k8s_spec.jq` is the exact patch to use +**minus its `/watch/` reduce clause** (middle path: delete the final +`reduce (.paths | keys[] ...)` stanza, keep the three nullable rules). + +### 2.1 Fetch specs (one-time per cluster minor, checked in) + +**Do not reuse anything in the legacy `gen/spec/` folder.** Those files are +OpenAPI v2 / Swagger 2.0 (`swagger.json`, `kuber.json`, …), which the new +generator does not accept at all (it reads OAS 3.0/3.1/3.2 only), plus one +k8s-1.24-era consolidated v3 file — both format and vintage are wrong. + +**Source of truth: the upstream `kubernetes/kubernetes` release tag** (decided +— more authoritative than any local cluster, decoupled from cluster quirks, +and the same mechanism the post-trial multi-minor matrix will use, see notes +§6). One file per group lives under `api/openapi-spec/v3/` at each tag, named +`apis_____openapi.json` (core is `api__v1_openapi.json`); +rename to the pipeline's `apis__.json` convention when +downloading. Fetch script — check it in as `gen/openapi_v1/fetch_specs.sh`: + +```sh +#!/usr/bin/env bash +# Fetch pristine k8s OpenAPI v3 group documents from the upstream release tag. +set -euo pipefail +K8S_TAG="${1:?usage: fetch_specs.sh }" +BASE="https://raw.githubusercontent.com/kubernetes/kubernetes/${K8S_TAG}/api/openapi-spec/v3" +DEST="$(dirname "$0")/specs" +mkdir -p "$DEST" + +# core, then the trial's group set (§ below); extend this list to add groups +GROUPS=" +api__v1 +apis__apps__v1 +apis__batch__v1 +apis__autoscaling__v1 +apis__autoscaling__v2 +apis__rbac.authorization.k8s.io__v1 +apis__networking.k8s.io__v1 +apis__storage.k8s.io__v1 +apis__policy__v1 +apis__events.k8s.io__v1 +apis__scheduling.k8s.io__v1 +apis__coordination.k8s.io__v1 +apis__certificates.k8s.io__v1 +apis__discovery.k8s.io__v1 +apis__node.k8s.io__v1 +apis__apiextensions.k8s.io__v1 +apis__apiregistration.k8s.io__v1 +" + +for g in $GROUPS; do + out="$DEST/$(echo "$g" | sed 's/__/_/g').json" + echo "fetching $g -> $out" + curl -fsSL -o "$out" "$BASE/${g}_openapi.json" +done + +# record provenance next to the specs +{ + echo "source: https://github.com/kubernetes/kubernetes tag ${K8S_TAG}" + echo "path: api/openapi-spec/v3/" + echo "fetched: $(date -u +%Y-%m-%dT%H:%M:%SZ)" + echo "files:" + (cd "$DEST" && sha256sum *.json | grep -v _patched) +} > "$DEST/SPECS_ORIGIN" +``` + +**Check in everything**: the fetch script, the pristine specs, the patched +specs (§2.2 output), `SPECS_ORIGIN`, and the generated modules (§2.3 output). +Together they make the generated layer fully reproducible and auditable — a +reviewer can verify `fetch → patch → generate` reproduces the tree exactly. +Pick the tag to match the k8s minor the trial targets (evaluation used a +v1.35 cluster, so `v1.35.0` or the latest v1.35.x patch tag is the natural +choice; patch releases don't change the API surface within a minor). + +Two things the upstream tag specs deliberately do **not** contain, both +already out of trial scope (§0): CRD-backed groups (JuliaHub CRDs, captured +later from a reference cluster's `/openapi/v3/apis//` when +that work happens) and aggregated APIs like `metrics.k8s.io` (served by +metrics-server, not the apiserver — same capture route if ever needed). + +The group list baked into `fetch_specs.sh` above is the minimum set for the +existing test suite; generating a subset keeps the checked-in module size down +(~30 MiB for all 27 cluster-served groups, core v1 alone is 6.7 MiB). Adding a +group later is mechanical: append it to the list, rerun fetch → patch → +generate, and re-emit the registry. + +### 2.2 Patch + +```sh +for f in gen/openapi_v1/specs/*.json; do + jq -f gen/openapi_v1/patch_k8s_spec.jq "$f" > "${f%.json}_patched.json" +done +``` + +The patch (guarded, applies to every document incl. ones missing the schemas): + +1. `meta.v1.Time` → `nullable: true` (wire: `lastProbeTime: null`) +2. `meta.v1.MicroTime` → `nullable: true` (wire: `eventTime: null`) +3. every array-typed property → `nullable: true` (Go nil slices marshal as + `null`; seen live on `CSINodeSpec.drivers`) + +### 2.3 Generate modules + +Module naming convention (same as the prototype sweep): strip the `apis?_` +prefix, split on `.`/`_`, camel-case, prefix `K8s` — `api_v1` → `K8sV1`, +`apis_apps_v1` → `K8sAppsV1`, `apis_rbac.authorization.k8s.io_v1` → +`K8sRbacAuthorizationK8sIoV1`. + +```julia +# gen/openapi_v1/generate.jl — run with the trial branch env activated +using OpenAPI +for f in filter(endswith("_patched.json"), readdir("specs"; join=true)) + base = replace(replace(basename(f), "_patched.json" => ""), r"^apis?_" => "") + modname = "K8s" * join(uppercasefirst.(split(replace(base, "." => "_"), "_"))) + OpenAPI.client(f; name = modname, + path = joinpath("..", "..", "src", "ApiImpl", "generated", "$(modname).jl")) +end +``` + +Strict mode is the default and **must stay on** (a strict-generation failure +means the patch list needs a new rule — that is signal, not noise). All 27 +docs pass at the pinned commit; ~39 s total. + +### 2.4 Emit the registry (replaces `api_typemap.jl` + `api_versions.jl`) + +Write `gen/openapi_v1/emit_registry.jl` producing +`src/ApiImpl/generated/registry.jl` with three tables. All three are derived +from the **spec JSONs**, not from parsing generated code: + +1. **Group-version → module** (replaces `APIVersionMap`): + + ```julia + const GROUP_MODULES = Dict{String,Module}( + "v1" => K8sV1, + "apps/v1" => K8sAppsV1, + ... + ) + ``` + + The group-version string for each spec file is recoverable from its + filename (`api_v1` → `"v1"`, `apis_apps_v1` → `"apps/v1"`). + +2. **(kind, apiVersion) → typed model** (replaces `Typedefs` + the + `kuber_type` payload sniffing). Source of truth: every k8s schema carries + `x-kubernetes-group-version-kind`. For each patched doc, for each schema + with that extension, map to the generated type name — the generator's + naming is deterministic: `io.k8s.api.core.v1.Pod` → `IoK8sApiCoreV1Pod` + (dot-split, camel-case each part, concatenate). Emit: + + ```julia + const KIND_TYPES = Dict{Tuple{String,String},Type}( # (apiVersion, kind) + ("v1", "Pod") => K8sV1.IoK8sApiCoreV1Pod, + ("apps/v1", "Deployment") => K8sAppsV1.IoK8sApiAppsV1Deployment, + ... + ) + ``` + + Verify the emitted table loads (every referenced type exists) as part of + generation — a mismatch means the naming assumption broke. + +3. **(verb, kind, scope) → operation function** (replaces the + `list_namespaced_$(snake_case)` string assembly + `eval` lookups in + `simpleapi.jl`). Source of truth: `operationId`s in the spec — the + generated function name is `lowercase(operationId)` + (`listCoreV1NamespacedPod` → `K8sV1.listcorev1namespacedpod`). k8s + operationIds are fully regular; parse each with + `x-kubernetes-action` (get/list/watch/create/update/patch/delete/ + deletecollection/connect) plus the path's `{namespace}` presence for scope, + and the response/body schema's `x-kubernetes-group-version-kind` for the + kind. Emit: + + ```julia + const OPS = Dict{Tuple{Symbol,Symbol,Symbol},Function}( + # (verb, kind, scope) scope ∈ (:namespaced, :cluster, :allns) + (:list, :Pod, :namespaced) => K8sV1.listcorev1namespacedpod, + (:list, :Pod, :allns) => K8sV1.listcorev1podforallnamespaces, + (:read, :Pod, :namespaced) => K8sV1.readcorev1namespacedpod, + (:create, :Pod, :namespaced) => K8sV1.createcorev1namespacedpod, + ... + ) + ``` + + This is deliberately a build-time table: no `eval`, no `isdefined` probing, + trim/precompile friendly, and a missing verb/kind is a table lookup miss + with a clean error instead of a reflective guess. + +`src/ApiImpl/ApiImpl.jl` becomes: include every `generated/K8s*.jl`, then +`registry.jl`. + +--- + +## 3. What each old construct becomes + +| Today (`0.2.x`) | Trial branch | +| --- | --- | +| `OpenAPI.Clients.Client(uri; get_return_type=kuber_type, ...)` | one `Mod.Client(uri; kwargs...)` **per group module** — a client is bound to its module's compiled `_SPEC`; sharing one across modules fails (verified: "requested node is not a compiled schema location"). Mirrors today's per-API-struct `apictx` pattern | +| `get_return_type=kuber_type` payload sniffing | gone — buffered responses decode to the documented type (specs are patched to be true); watch frames second-stage decode via `KIND_TYPES` | +| `check_api_response(result, http_resp)` on `(result, resp)` tuples | operations return the value or throw `OpenAPI.Runtime.ApiError` (non-2xx). Catch `ApiError` and rewrap as `KuberException` (§4.4) | +| `apimodule(ctx).eval(Symbol("list_namespaced_$(_O_)"))` | `OPS[(:list, O, :namespaced)]` table lookup | +| `Typedefs.CoreV1.Pod` etc. | `KIND_TYPES[("v1", "Pod")]`; keep a deprecation shim only if downstream code uses `Typedefs` directly | +| `kuber_obj(ctx, dict)` / `convert(T, dict)` | `OpenAPI.Runtime._decode(T, dict, false)` with `T = KIND_TYPES[(apiVersion, kind)]` (see §5.5; `_decode` is runtime-internal — pin exactly, and ask upstream for a public `decode` entry point) | +| `OpenAPI.val_format(::Val{Symbol("int-or-string")})` | delete — v3 specs declare `IntOrString` as `oneOf: [integer, string]`, planner maps it natively | +| legacy channel streaming inside generated ops | `stream_to = Channel(n)` kwarg on the same list op + `accept`/codec (§4.5) | +| `Downloads.Response` header handling, `header(::Downloads.Response, ...)` | delete; `with_http_info=true` returns `ApiResponse{T}` with `.headers` when headers are needed | +| `ctx.client.headers["Connection"] = ...`, `httplib` selection | delete both — HTTP.jl 2.x only; pass persistent defaults via `Client(...; headers=..., request_options=...)` | +| `set_timeout` / `get_timeout` / `with_timeout` via `client.timeout[]` | store a `request_options::NamedTuple` on `KuberContext` (e.g. `(readtimeout = N,)`) and pass per call as `request_options`; `with_timeout` becomes a context-local override. Characterize exact HTTP.jl 2.x option names during Phase 2 | +| `@K_str` export | vestigial — it is exported but defined nowhere in `src/` today. Drop the export | + +--- + +## 4. Core rewrite (`src/helpers.jl`) + +### 4.1 Context + +```julia +mutable struct KuberContext + server::String + clients::Dict{Module,OpenAPI.Runtime.Client} # lazily built per group module + client_kwargs::NamedTuple # credentials/headers/request_options defaults + apis::Dict{Symbol,Vector{Module}} # discovered group → available modules (preferred first) + modelapi::Dict{Symbol,Module} # kind → module for the simple symbol API + namespace::String + default_retries::Int + retry_all_apis::Bool + initialized::Bool +end +``` + +`client_for(ctx, mod)` = `get!(() -> _new_client(ctx, mod), ctx.clients, mod)`, +where `_new_client` constructs `mod.Client(ctx.server; require_credentials=false, +ctx.client_kwargs...)` **and registers the watch codec** (§4.5). `set_server` +resets `ctx.clients` and re-probes if asked. Keep `KuberWatchContext`, +`KuberEventStream = Channel{Any}`, `set_ns`, `set_retries`, `retries` as they are. + +Credentials/TLS: the old path passed client kwargs through to Downloads/HTTP. +The new `Client` takes `headers=`, `request_options=` (HTTP.jl kwargs — this is +where `sslconfig`/cert options go), and `credential!`/`authorization!` for spec +security schemes. For the trial (kubectl proxy / in-cluster bearer token), a +`headers = ["Authorization" => "Bearer ..."]` default plus `request_options` +TLS passthrough covers it; verify against a token-auth cluster in Phase 4. + +### 4.2 Discovery (`set_api_versions!`) + +Keep the same discovery *semantics* (probe server, tolerate gaps, `override` +kwarg) but implement the two probes with plain HTTP.jl + JSON — they were the +only reason the old `ApisApi`/`CoreApi` generated wrappers were needed: + +- `GET {server}/api` → core versions (expect `{"versions": ["v1"]}`) +- `GET {server}/apis` → groups with `preferredVersion` and `versions` + +For each discovered `group/version`, look up `GROUP_MODULES`; skip (with +`verbose` info) when we don't ship that group — same tolerance as today. Fill +`ctx.apis` (preferred version first, then other supported versions — preserving +today's `KApi` list ordering) and build `ctx.modelapi` by iterating +`KIND_TYPES` per module (replaces `build_model_api_map`'s `names()` scan). +Keep the `:PodLog => modelapi[:Pod]` special-case (§5.4). + +### 4.3 Retries (`k8s_retry`) + +Keep the `ExponentialBackOff` wrapper and `max_tries`/`tps` interface, replace +the retry condition: + +- `ApiError` with `.status in [0, 500, 501, 502, 503, 504]` → retryable + (confirm the field name on `OpenAPI.Runtime.ApiError` — it carries the + response; look at `src/runtime.jl` at the pin). +- Transport-level failures now surface as HTTP.jl 2.x exceptions + (`HTTP.RequestError`/connect errors) instead of + `is_request_interrupted` — that helper no longer exists. Retry those when + the watch stream (if any) is still open, exactly mirroring today's + `stream === nothing || isopen(stream)` guard so an intentional + `close(stream)` still terminates instead of retrying (this is the semantics + of Kuber PRs 67/68 — preserve them). +- **New case the old code never saw**: a mid-stream truncated item closes the + watch channel with `OpenAPI.Runtime.DecodeError` instead of ending silently. + Treat close-with-`DecodeError` on a still-wanted watch as retryable + (re-establish from last seen `resourceVersion`). + +Phase-2 first task: write a tiny characterization script (kill a watch's +connection server-side, close the channel client-side, hit a 503) and pin the +exact exception types observed — then encode them in `k8s_retry_cond`. + +### 4.4 Exceptions + +Keep `KuberException` shape (code, message, status, response) for downstream +compat. Build it from `ApiError`: status code and raw body are on the error; +when the body parses as a k8s `Status` object, use its `message`/`code` +overrides exactly as today. + +### 4.5 Watch plumbing + +At client construction (every per-module client — cheap and uniform): + +```julia +OpenAPI.Runtime.codec!(client, "application/json;stream=watch"; + decode = (bytes, _) -> JSON.parse(String(bytes))) +``` + +The codec only fires for calls that pass +`accept = "application/json;stream=watch"` (verified at the pin; buffered +calls on the same client are untouched). The internal watch call is then: + +```julia +raw = Channel{Any}(buffersize) +OPS[(:list, O, scope)](args...; client, watch = true, + resourceversion = rv, accept = "application/json;stream=watch", + stream_to = raw, kwargs...) +``` + +Each item on `raw` is a JSON object dict `{"type": ..., "object": ...}`. +Second-stage decode into the public event (see §5.3) via `KIND_TYPES` on +`object.kind`/`object.apiVersion` — this is the direct replacement of +`kuber_type`'s WatchEvent branch, verified live including the typed decode. + +--- + +## 5. Simple API rewrite (`src/simpleapi.jl`) + +### 5.1 Verb functions + +`get`/`list`/`put!`/`update!`/`delete!` keep their exact signatures and +semantics; internals change to: resolve module (`apiversion` kwarg via +`GROUP_MODULES`, else `ctx.modelapi[O]`), resolve op via `OPS`, call with +`client = client_for(ctx, mod)` and value-or-throw handling wrapped in +`k8s_retry`. Scope resolution keeps today's fallback chain (namespaced → +cluster → all-namespaces), now as table probes instead of `isdefined` probes. +Verb mapping from today's name assembly: `read_*` → `:get`(read), +`list_*` → `:list`, `create_*` → `:create`, `patch_*` → `:patch`, +`delete_*` → `:delete`, `watch_*` → handled by §4.5 (no dedicated watch ops in +the middle path — `watch=true` on the list/read op). + +Casing note: **all generated kwargs are lowercase** — `labelselector`, +`resourceversion`, `fieldselector` (not `label_selector`). Keep accepting the +old snake_case kwargs at the simpleapi boundary and translate, so downstream +call sites don't churn. + +### 5.2 `update!` (patch) + +The generated patch ops document k8s's patch media types. Pass the patch type +as the request content type: + +```julia +OPS[(:patch, O, scope)](name, ns, patchobj; client, + content_type = patch_type) # e.g. "application/merge-patch+json" +``` + +Verify during implementation that the body encoder honors `content_type` for +the `+json` variants (it should — they are JSON-family media types; if not, +this is a small upstream ask). + +### 5.3 Watch API and events + +Keep the two public entry points (`watch(fn, ctx; ...)` and +`watch(ctx, O, outstream, ...)`) and `KuberEventStream`. Preserve today's +event protocol on the stream: + +1. first item: the initial typed List result (e.g. `PodList`) — unchanged; +2. subsequent items: watch events. Emit a Kuber-owned struct instead of the + legacy generated `WatchEvent`: + + ```julia + struct KuberEvent + type::String # ADDED / MODIFIED / DELETED / BOOKMARK / ERROR + object::Any # typed model via KIND_TYPES, or raw dict if kind unknown + end + ``` + + (`event.type` keeps working at call sites — nicer than the generated + `type_` rename. `kuber_obj(ctx, event.object)` call sites in tests become + unnecessary but keep `kuber_obj` accepting dicts for compat.) + +Re-watch loop: on retryable stream death (§4.3), re-issue with +`resourceversion` from the last event's `object.metadata.resourceversion`; +surface `410 Gone` (`ApiError`) as a fresh list+watch, matching k8s watch +protocol. Today's code only resumes from the initial list RV — this is a +strict improvement; keep it small. + +### 5.4 `get_logs` / PodLog + +`get(ctx, :PodLog, name)` maps to `K8sV1.readcorev1namespacedpodlog(name, ns; +client, kwargs...)` returning `String` (text/plain — the new runtime decodes +text media to strings). Wire `:PodLog` as a special row in `OPS` +(`(:get, :PodLog, :namespaced) => readcorev1namespacedpodlog`) so the generic +path just works. Kwargs are lowercase now: `sinceseconds`, `taillines`, etc. — +translate at the boundary per §5.1. + +### 5.5 `kuber_obj` and conversions + +```julia +kuber_obj(ctx, j::AbstractDict) = OpenAPI.Runtime._decode( + KIND_TYPES[(get(j, "apiVersion", "v1"), j["kind"])], + j, false) +kuber_obj(ctx, s::String) = kuber_obj(ctx, JSON.parse(s)) +``` + +Delete the `convert(::Type{T}, ::String/Dict)` and +`convert(Dict, model)` piracy; for model→dict (used by `delete!`/`update!` on +model args), read fields directly (`v.kind`, `v.metadata.name`) — the new +models are plain typed structs, no JSON round-trip needed. Delete +`_parse_json`'s `dicttype` workaround (nothing depends on `Dict{String,Any}` +anymore; JSON.Object is fine everywhere — `_decode` accepts it, verified). + +### 5.6 `ABSENT` vs `nothing` — the one user-visible semantic change + +Old models: absent field → `nothing`. New models: absent → `ABSENT` +(`OpenAPI.Runtime.Absent`), explicit JSON `null` → `nothing` (the patched +nullable fields make this reachable: `lastProbeTime`, `eventTime`, nil +arrays). Add one helper and use it at every Kuber-internal field access: + +```julia +_field(x, default=nothing) = x isa OpenAPI.Runtime.Absent ? default : x +``` + +and document the change prominently in the trial branch README for downstream +users (grep JuliaHub consumers for `=== nothing` checks on Kuber model fields +when the trial graduates). + +Also inherited: generated field names are lowercase with `_` suffix on +collisions — `metadata.resourceversion`, `event.type_` (avoided at the +simpleapi surface by §5.3, but raw model access sees them). + +--- + +## 6. Testing the trial branch + +### Phase-gate checks (run after each phase) + +1. **Generation** (Phase 1): pipeline runs clean; registry loads; every + `KIND_TYPES`/`OPS` entry resolves. `julia --project -e 'using Kuber'` + precompiles. +2. **Offline unit** (Phase 2–3): registry lookups; `kuber_obj` round-trips a + pod JSON; `KuberException` from a synthetic `ApiError`; kwarg translation. + No cluster needed. +3. **Live integration** (Phase 4): adapt `test/runtests.jl` — it is already + a good end-to-end suite (component status, namespace listing, versioned + model creation, job create/delete, watch events, watch-processor-failure + propagation, timeouts). Expected diffs: `Typedefs.CoreV1.WatchEvent` → + `Kuber.KuberEvent`; `event.object` already typed; timeout tests rewritten + against `request_options`. Run against k3s + `kubectl proxy` like the + prototype did. +4. **Prototype cross-checks** (already written, run as-is against the branch's + pinned OpenAPI): `gen/openapi_v1_prototype/k8spristine_v3.jl` (accept-codec + watch) and `smoke_groups.jl` (all-groups strict lists) — these validate the + pinned OpenAPI commit independently of Kuber code, useful to bisect "is it + Kuber or upstream" during bring-up. +5. **`test/watch_latency.jl`**: re-verify small-chunk incremental delivery + through the Kuber watch wrapper (upstream semantics verified at 0.0 s + first-item warm; this checks Kuber didn't add buffering on top). + +### Acceptance criteria for the trial + +- [ ] `using Kuber` on Julia 1.11+ with only Dates/HTTP/JSON/OpenAPI deps +- [ ] existing `runtests.jl` scenarios green against a live cluster (with the + documented expected diffs) +- [ ] watch: events flow, `close` stops cleanly, processor death kills the + watch (Kuber #67 semantics), interrupted watch retries (#68 semantics), + truncated-stream retry works +- [ ] strict validation on for all buffered calls (no + `validate_responses=false` anywhere in the trial — the nullable patches + should make strict work; if a new spec lie appears, that's a new patch + rule, not a validation opt-out) +- [ ] `put!`/`update!`/`delete!` round-trip a Job and a Deployment +- [ ] `get_logs` returns pod logs +- [ ] precompile + load time measured and recorded (baseline: 27 modules ≈ + 29 s uncompiled; expect package precompilation to absorb it — record + actual TTFX for `list(ctx, :Pod)`) + +--- + +## 7. Suggested implementation order + +| Phase | Work | Estimate | +| --- | --- | --- | +| 1 | branch + Project.toml + generation pipeline + registry emission | 0.5–1 day (pipeline exists as prototype; registry emitter is the new work) | +| 2 | helpers.jl rewrite: context, clients, discovery, retry characterization, exceptions | 1–1.5 days | +| 3 | simpleapi.jl rewrite: verbs, watch, logs, kuber_obj | 1–1.5 days | +| 4 | test adaptation + live runs + fixes | 1 day | +| — | total | ~4–5 days of focused work | + +## 8. Known traps (all hit during evaluation — don't rediscover them) + +1. **One client per module.** `Runtime.Client` is bound to the module's + compiled `_SPEC`; cross-module reuse errors out. +2. **Name collisions in generated code**: `type` → `type_`, `continue` → + `continue_`; all identifiers lowercase (`photourls`, `resourceversion`). +3. **`ApiError` on any non-2xx** — code that pattern-matched + `(result, response)` tuples must move to try/catch. +4. **Watch channel closes with an error** on truncated streams (deliberate + upstream change vs legacy silent EOF) — consumer loops must handle + `take!`/iteration throwing. +5. **The `accept` kwarg is what scopes the watch codec** — forget it and + frames decode against the List schema and fail; the codec alone does + nothing against a real apiserver (it replies bare `application/json`). +6. **`_decode` needs the tolerant flag `false` explicitly** in second-stage + decode calls; and index open-struct payloads via `.additional_properties` + on `RawExtension`-typed fields. +7. **Byte-stability of generated code holds per-commit only.** Regenerate + everything whenever the OpenAPI pin moves; never hand-edit generated files. +8. **Watch-path ops don't exist in the middle path** (no `/watch/` patch), so + nothing in Kuber may reference `watch*` operationIds; k8s marks them + deprecated anyway. +9. **`ctx.modelapi` kinds come from `KIND_TYPES`, not `names(module)`** — the + old `names()` scan pulled in every model including non-top-level ones; + `x-kubernetes-group-version-kind` gives exactly the addressable kinds. + +## 9. Reference material + +- [`OpenAPIv1RewriteNotes.md`](OpenAPIv1RewriteNotes.md) — full evaluation + findings, upstream status, route comparison (§5), architecture (§6). +- [`gen/openapi_v1_prototype/`](gen/openapi_v1_prototype/) — runnable: patch + script, live bake test (8/8), pristine + accept-codec test (11/11), + all-groups sweep (74/74 strict live ops). +- Evaluation artifact (shareable summary): + https://claude.ai/code/artifact/ca41c458-051a-433c-a274-0b4bc1e213a3 +- Upstream PR: https://github.com/JuliaComputing/OpenAPI.jl/pull/103 — README + on the branch documents `Client` kwargs, `codec!`, `credential!`, + `stream_to`, `with_http_info`, `request_options`. +- Pinned OpenAPI source of truth for runtime internals: + `src/runtime.jl` at `1ff9ba8` (`ApiError`, `Absent`, `_decode`, + `_stream_codec_media`). diff --git a/OpenAPIv1TrialResults.md b/OpenAPIv1TrialResults.md new file mode 100644 index 00000000..8ed5d19c --- /dev/null +++ b/OpenAPIv1TrialResults.md @@ -0,0 +1,349 @@ +# Kuber.jl on OpenAPI.jl 1.0 — trial branch results + +**Status: implementation record, written 2026-08-13.** What the +`openapi-v1-trial` branch actually does, where it departs from +[`OpenAPIv1TrialBranchPlan.md`](OpenAPIv1TrialBranchPlan.md) and why, the +measured numbers §6 asks for, and what is left. Read this alongside the plan: +the plan is the design, this is the outcome. Where they disagree, this file is +current. + +Built against OpenAPI.jl `1ff9ba8` (`quinnj/OpenAPI.jl`, branch +`codex/production-rewrite`), Kubernetes v1.35.4 specs, verified live against a +k3s v1.35.4 cluster through `kubectl proxy`. Local runs were all on **Julia +1.12.6**; the 1.11 floor in `[compat]` was exercised by CI (run 31701082665) and +holds, as does nightly. + +CI's cluster version is load-bearing, which it was not on the 0.2.x line. The +first run inherited `master`'s kind pin (`v0.11.1`, node image +`kindest/node:v1.21.1`) and failed one assertion — a 1.21 apiserver prefers +`autoscaling/v1`, so discovery cannot fill `ctx.apis[:Autoscaling][1]` with the +v2 module — while all 3824 offline assertions passed unchanged. The workflow now +pins kind `v0.32.0` with the `v1.35.5` node image, matching the spec tag. Any +future spec bump has to move that pin with it. + +## 1. Deviations from the plan + +Every one of these came out of implementation or measurement, not preference. + +### 1.1 Eight patch rules, not three (plan §2.2) + +The plan's three nullable rules are all present. Two more were needed, both +found by exercising verbs the evaluation never had — it only ever listed and +watched: + +4. **`*/*` request bodies → `application/json`.** k8s documents `*/*` for every + create/replace body. No client can encode to that: the runtime has no `*/*` + encoder, and would send `Content-Type: */*` if it had one. We always send + JSON and k8s always accepts it, so saying so makes the document true. +5. **DELETE 2xx responses → the empty schema.** k8s documents `Status`, but a + delete usually answers with the deleted object. Verified live: deleting a Job + returns the Job, deleting a Deployment returns a Status — *both* shapes occur, + which is the ambiguity the old client's `get_return_type` sniffing hid. + `oneOf: [Status, resource]` was tried and rejected: the generator emits one + wrapper type per response code per media type (eight for a single delete). + The empty schema states what is actually true, and `delete!` restores the type + from the payload's `kind`/`apiVersion` through `KIND_TYPES` — the same + second-stage decode watch frames use. + +6. **`application/json-patch+json` bodies become an array.** Added 2026-08-14. + k8s documents one schema — `meta.v1.Patch`, `type: object` — for all five + patch media types, but a JSON Patch body is an array of RFC 6902 operations. + The generated `Patch` model can only hold an object, so every json-patch + caller failed to encode, which is most of the production patch traffic + (`OpenAPIv1ConsumerGaps.md` C8). Declared once as a component and referenced, + rather than inlined per operation: inlining emits one item type per patch + operation (132 in apps/v1 alone), the shared component emits one. + +7. **`allOf`-wrapped `$ref`s collapse to the `$ref`.** Added 2026-08-14. k8s + never writes a bare `$ref` for a property: it wraps it in a single-element + `allOf` so it can hang a `description` beside it, because a `$ref` with + siblings is undefined in OAS 3.0. Read literally that wrapper is a new + schema, so the generator minted a type per use site — `Pod.spec` was + `IoK8sApiCoreV1PodSpec2` (the real `PodSpec` component went unreferenced), + every kind had its own `…Metadata` rather than the shared `ObjectMeta`, and + `PodList.items` had its own element type, which made + `item isa kind_to_type(ctx, :Pod)` false — a regression from `master`, where + those were all one type (`OpenAPIv1ConsumerGaps.md` G18). + + 1290 sites, in two positions: property schemas and the `items` of array + properties. **Halved the layer: 2252 generated types → 1098, ~24 MiB → ~18 + MiB.** Scoped to those two positions rather than walked recursively, because + `apiextensions`' `JSONSchemaProps` describes JSON Schema itself and so has + properties *named* `allOf`, `nullable` and `items` — a recursive walk + corrupts the CRD document. Guarded on shape (single-element `allOf`, bare + `$ref` element) so a future spec that differs is noticed rather than mangled. + `test/registry.jl` gates it on type identity, not on the type count. + +8. **`resourceVersion` is declared on single-object reads.** Added 2026-08-14. + k8s documents it on every *list* operation and on none of the reads, but the + apiserver honours it on both — verified live: an impossible version answers + 504 "Too large resource version". A consumer asking for a read "not older + than" a version it already saw had no parameter to send + (`OpenAPIv1ConsumerGaps.md` G17). Added only to paths ending in `{name}`, not + to subresources like `pods/log` where a resource version is meaningless. + + Sequenced deliberately after the retry work: rules 1–7 make the document + describe what the server already does with requests Kuber already sends, but + this one changes which requests Kuber can *construct*, and its natural + failure is a 504 that blocks for the apiserver's wait. That was not worth + adding while `max_tries=1` still meant ten requests (G20). + +Strict generation and strict response validation stayed on throughout. There is +no `validate_responses=false` anywhere in `src/`. + +That rule also made `OP_BODIES` map media type → body type, since a PATCH now +genuinely has two body types. + +### 1.2 `OPS` is keyed by module, and two tables were added (plan §2.4) + +`OPS::Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}` — `(module, verb, kind, +scope)`. The plan's 3-tuple cannot express two shipped versions of one kind, and +the trial ships two: `autoscaling/v1` and `autoscaling/v2` both define +`HorizontalPodAutoscaler`. Callers still resolve the module first (from the +`apiversion` kwarg or `ctx.modelapi`) exactly as before, so the resolution flow +is unchanged. + +Two tables the plan does not mention: + +- **`OP_PARAMS`** — positional argument names per operation. Generated + positional order is *path* order, so the namespace comes **first** + (`readcorev1namespacedpod(namespace, name)`) and a required body last. That is + the reverse of the old client, and worth having as build-time data rather than + a rule each call site re-derives. +- **`OP_BODIES`** — body type plus documented request media types, for + operations with a required body. `update!` needs both: a patch body must be + built as the generated `Patch` type (an open object, so a `Dict` cannot be + passed through), and k8s documents only the five patch media types — there is + no plain `application/json` for a PATCH. + +Two things the emitter learns from the specs rather than assuming: + +- **Subresource kinds come from the parent resource's path**, not the + operation's own `x-kubernetes-group-version-kind`, which on a subresource names + the *subresource's* type (`pods/exec` is `PodExecOptions`, `pods/eviction` is + `policy/v1 Eviction`). Parent kind plus capitalized subresource reproduces the + operationId tails exactly — which is how `:PodLog` (plan §5.4) reaches the + table through the generic path instead of as a special case. +- **Generated identifiers are read off the planner**, not recomputed. The naming + rules normalize non-identifier characters, dodge Base/Core and reserved names, + and disambiguate collisions with a counter. A hand-rolled version got + `io.k8s.apiextensions-apiserver...` wrong on the first attempt and would have + drifted silently later. + +### 1.3 The watch loop is shaped by the runtime, not the plan (plan §4.3, §5.3) + +`test/characterize_retries.jl` exists to pin the runtime's exception types +before `k8s_retry_cond` was written, as §4.3 asks. Three of its findings +contradict the plan: + +| Plan says | Actually | +| --- | --- | +| retry transport failures "when the watch stream is still open, exactly mirroring today's `isopen(stream)` guard" | the guard left the retry path entirely. The watch call returns at the *response head*, so it can never be the in-flight call being retried; stop-vs-re-watch moved into the watch loop | +| 410 Gone is an `ApiError` | it is an **in-stream `ERROR` event** carrying `Status(reason=Expired, code=410)`; the HTTP status is 200 | +| a 410 becomes "a fresh list+watch" | true after all, but only since 2026-08-14. The loop first re-watched with **no** `resourceVersion` — simpler, and k8s answers it with synthetic `ADDED`s for current state — until [G1](OpenAPIv1ConsumerGaps.md) showed that hides deletions that happened while the watch was gone. It now lists again and pushes that list as a resync frame | + +Because the call returns at the response head, `list`'s watch branch **pumps the +stream inline** and returns only when the watch is over. Delegating and returning +would close the stream immediately and yield zero events; pumping inline is what +keeps `watch(streamprocessor, ctx, list, O)` and both of its `finally +close(stream)` blocks working as they did under the 0.2.x client. + +Recovery rules in the loop, all measured rather than assumed: + +- the **consumer closing the public stream is the only stop signal** (#67/#68). A + connection dropped on an item boundary closes *cleanly*, indistinguishable + from a watch ending normally on `timeoutseconds`, so a clean close cannot mean + "stop". +- a clean end **re-watches** from the last `resourceVersion` seen. +- an **expired `resourceVersion`** (the in-stream 410) **re-lists**, pushes that + list onto the stream, and watches from its `resourceVersion`. The contract is + that a list object on the stream means complete current state — the first frame + and every resync frame alike — so a consumer that replaces its cache on one is + correct without knowing expiry exists. `push_initial=false` opts out of both. +- a **truncated item** closes the channel with `DecodeError`; re-watch. +- a **connection aborted mid-chunk** — an apiserver restart or network drop, the + one #68 shape a clean end does not stand in for — closes the channel with an + HTTP.jl error (`ParseError: unexpected EOF while reading HTTP/1 data`). + Recovering from `DecodeError` alone left the watch dead here; anything + `k8s_retry_cond` accepts is now recovered from too. +- a stop takes effect within ~250 ms **regardless of traffic**. Without that, the + pump only noticed a stop when the next frame arrived, which on a quiet resource + left `watch()` hanging and kept the `@sync` alive after a processor died — the + deaf watch #67 fixed. +- consecutive establishments that deliver **no events back off** 0.25 s → 8 s, + reset by any delivered event. `k8s_retry` wraps only the *establish* call, so a + server answering 200 and ending the stream empty is not a failure and nothing + else throttled it — reachable with an unservable `resourceVersion` or a proxy + dropping long connections, and it would have hammered the apiserver. + +### 1.4 Smaller departures + +- **`kuber_props`** was added. k8s string maps (`metadata.labels`, + `metadata.annotations`) decode to a generated *open struct*, not a `Dict`, so + indexing the field silently fails. Found the hard way: `watch_latency.jl` + reported every MODIFIED event as MISSED because of it. Labels and annotations + are far too common to make callers reach into `additional_properties`. +- **`kuber_type`** survives as `kuber_type(json)` — a payload→type lookup — rather + than being deleted. `@K_str` is dropped, as planned. +- **Timeouts**: `set_timeout` sets HTTP.jl's `request_timeout`, and watch calls + drop it (a watch has no meaningful overall deadline; k8s bounds one with the + `timeoutseconds` query parameter). `set_request_options` passes anything else + through. +- **Deps** are `Dates`, `HTTP`, `JSON`, `OpenAPI` plus the `Base64` and `UUIDs` + stdlibs the generated modules import — the plan listed only `Dates`. `Random` + was audited and is genuinely unused. + +## 2. Measurements (plan §6 acceptance) + +Julia 1.12.6, k3s v1.35.4 via `kubectl proxy`, 18 group modules (~18 MiB of +generated Julia, 1098 types). + +**Re-measured 2026-08-14 after patch rules §7 and §8**, which halved the +generated type count (2252 → 1098). The "before" column is the original +measurement at 2252 types, kept because the delta is the point. + +| | Before (2252 types) | After (1098 types) | +| --- | --- | --- | +| Package precompilation | ~22 s | **14.4 s** | +| `using Kuber` (precompiled) | 0.36 s | **0.24 s** | +| Discovery (`/api` + `/apis`) | 0.22 s | 0.22 s | +| **TTFX — first `list(ctx, :Pod)`** | ~15–16 s | **12.4 s** (12.36, 12.58) | +| Steady-state `list(ctx, :Pod)` | 11.5 ms | **8.6 ms** (min of 6; 2 pods) | +| — of which response schema validation | 78 % | **72 %** (strict 8.4 ms vs tolerant 2.3 ms) | +| First call into a second group module | 1.2 s | 1.0–1.3 s | +| Watch reaction time, after warmup | 5.6–11.2 ms median | 5.5–10.4 ms median, 0 missed | +| Generation: patch → generate 18 docs | ~29 s | 0.3 s patch + 29.2 s generate | +| Registry emission | ~100 s | 95.4 s | + +Everything that is compilation got cheaper by roughly a third — precompilation, +TTFX, and the per-call cost — which is what halving the type count buys. Nothing +that is I/O moved: discovery is unchanged, as it should be. + +**Comparability matters more than it looks for the steady-state row.** The +original was measured against a `default` namespace holding 2 pods. On a cluster +where the live suite has run repeatedly that namespace fills up — it held 35 when +this re-measurement started, and the same call took 116 ms. The number is +dominated by per-item validation, so it is only meaningful alongside an item +count. Measured here at 2 pods to match. + +The freshly built compile cache is 55 MB. + +Rerunning the whole generation chain reproduced `src/ApiImpl/generated/` and the +patched specs **byte-identically** to what is committed, which is the +reproducibility claim `gen/openapi_v1/README.md` makes, checked rather than +asserted. + +TTFX is still the one number that stands out, at 12.4 s. It is first-call +compilation of the generated operation plus the validation engine, not I/O — +precompilation absorbs load time but not inference. Halving the type count took +about 3 s off it, which suggests the remainder is the validation engine and the +operation itself rather than the model types. A `PrecompileTools` workload over +one list/get/watch path would likely absorb most of what is left; that is a +follow-up, not a trial fix. + +### Test suite + +`julia --project test/runtests.jl` — offline suites first, then the live +integration suite (skipped with a warning when no server is reachable; +`KUBER_TEST_SERVER` overrides the endpoint). + +| Suite | Assertions | Needs a cluster | +| --- | --- | --- | +| `registry.jl` | 5694 | no | +| `register.jl` | 58 | no | +| `helpers.jl` | 130 | no | +| `simpleapi.jl` | 90 | no | +| `retries.jl` | 56 | no (fake apiserver) | +| `watch_recovery.jl` | 70 | no (fake apiserver) | +| live integration | ~830 | yes | + +**The live count is not a stable number, and should not be read as one.** The +`Watch Events` testset asserts three times per event it observed, so the total +moves with whatever else is happening on the cluster — runs minutes apart have +differed by more than a hundred assertions with no code change between them. +Compare suites, not totals. The metrics testset adds a smaller variation: it +asserts on pod metrics only when metrics-server has collected some, and skips +entirely when the cluster does not serve `metrics.k8s.io` — `kind` does not, so +CI runs it as a no-op. + +Manual probes, not part of `runtests.jl`: `characterize_retries.jl` (rerun +whenever the OpenAPI pin moves) and `watch_latency.jl`. + +Independent of Kuber, `gen/openapi_v1_prototype/k8spristine_v3.jl` passes 11/11 +against the pinned OpenAPI, confirming upstream behaves as the evaluation +recorded. `smoke_groups.jl` was not rerun: it needs all 27 cluster-served group +documents captured and generated, and the trial's own 17 modules plus the live +suite cover the same ground. + +### Expected diffs in the adapted test suite + +- `batch/v1beta1` and `batch/v2alpha1` CronJobs, and the `apps/v1beta2` / + `apiregistration.k8s.io/v1beta1` overrides, do not exist on a 1.35 server. + `autoscaling` is now the group that serves one kind in two versions, so it is + what exercises versioned typing and the `override` kwarg. +- `Typedefs.CoreV1.WatchEvent` → `KuberEvent`; `event.object` is already typed, + so the `kuber_obj` round-trip is gone. +- `delete!` assertions compare `kuber_kind`, not the type: every group module has + its own `Status` type, so a `batch/v1` delete can never be `isa` core's. +- the timeout test is rewritten against `request_options`; there is no + `DEFAULT_TIMEOUT_SECS` to compare with, and unset means no deadline. +- the `killall kubectl` teardown is dropped — it worked around a libcurl segfault + and Downloads.jl is gone. + +## 3. Known limitations and follow-ups + +Out of trial scope by decision (plan §0), and since revisited: + +- **Aggregated APIs and CRD groups** are absent from release-tag specs, because + they are not part of Kubernetes. Both halves of that gap are now closed as + mechanism: `fetch_specs.sh --from-cluster` captures a group version's real + OpenAPI document from a live apiserver (provenance in `SPECS_CAPTURED`), and + `Kuber.register!` (`src/register.jl`) merges an out-of-tree generated layer + into the registry — the replacement for `KuberContext(apimodule)`. +- **`metrics.k8s.io/v1beta1` is shipped again** (captured 2026-08-14 from k3s + v1.35.4), as the 0.2.x line shipped it. No new patch rule was needed and it is + covered live by `test_metrics`, which skips on clusters without + metrics-server. +- **Custom metrics**: `list_custom_metrics` / `list_namespaced_custom_metrics` + are implemented again — the same one-liners as `master`, over + `list(ctx, :MetricValue, "//")`. The group itself is + **captured and deliberately not shipped**: a document from `prometheus-adapter` + v0.12.0 (2026-08-15, kept in `gen/openapi_v1/reference-captures/`) has the + predicted adapter-independent schemas but operations that carry no + `x-kubernetes-group-version-kind` and address metrics through a three-variable + path, so `emit_registry.jl` would emit no `OPS` for it and `_positional` could + not fill it — and no code in JuliaRun or the monorepo actually calls the API. + See `OpenAPIv1ConsumerGaps.md` C5. +- **One k8s minor.** The multi-minor matrix and connect-time switching are a + post-trial concern; the pipeline already supports adding groups and minors. + +Found during the trial: + +- **TTFX ~15 s** — a `PrecompileTools` workload is the obvious next step. +- **Response validation is 78 % of a steady-state list.** Correct and worth + keeping for a trial, but a real cost to weigh for hot paths. +- **Shared meta types are per-module.** `Status`, `DeleteOptions` and + `WatchEvent` exist separately in every group module, so cross-module type + identity is impossible. `KIND_TYPES` resolves them by policy (own + group-version, then core, then alphabetically first) and `kuber_kind` is the + intended way to test them. If this bites downstream, the fix is upstream: + hoisting shared schemas into one module. +- **Unframed streaming responses buffer until close.** Not an issue against a + real apiserver (k8s uses `Transfer-Encoding: chunked`), but a proxy that + stripped chunking would silently destroy watch latency. + +## 4. Before this graduates + +- [ ] PR JuliaComputing/OpenAPI.jl#103 merged and tagged; drop `[sources]`, set + compat to the tag, and **regenerate everything** — generated output is + byte-stable only within a pinned commit. +- [x] Verify on Julia 1.11 — done by CI, which also runs nightly green. +- [ ] Close the consumer gaps in + [`OpenAPIv1ConsumerGaps.md`](OpenAPIv1ConsumerGaps.md). That survey + supersedes this line: the `ABSENT`/open-struct sweep it asked for turns out + to be a small part of it, and the blocking item is that JuliaRun plugs its + own generated layer in through `KuberContext(apimodule)`, which this branch + removed. +- [ ] Verify against a token-auth cluster: the trial only exercised + `kubectl proxy`, so the `headers`/`request_options` credential path is + untested against real TLS and bearer tokens. diff --git a/Project.toml b/Project.toml index 86b94a19..12817fff 100644 --- a/Project.toml +++ b/Project.toml @@ -4,22 +4,27 @@ authors = ["JuliaHub Inc."] keywords = ["kubernetes", "client"] license = "MIT" desc = "Julia Kubernetes Client" -version = "0.7.11" +version = "0.8.0-dev" [deps] +Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" -Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3" JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" -Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" OpenAPI = "d5e62ea6-ddf3-4d43-8e4c-ad5e6c8bfd7d" -TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53" +UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[sources] +OpenAPI = {url = "https://github.com/quinnj/OpenAPI.jl", rev = "1ff9ba8dacf5857f0e712d26cc16e6a67bbdc46a"} [compat] -Downloads = "1" -OpenAPI = "0.1,0.2" -JSON = "0.21, 1" -TimeZones = "1" -julia = "1" +Base64 = "1.11" +Dates = "1.11" +HTTP = "2" +JSON = "1.7" +OpenAPI = "1" +UUIDs = "1.11" +julia = "1.11" [extras] Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" diff --git a/README.md b/README.md index beb2963c..262d1c61 100644 --- a/README.md +++ b/README.md @@ -4,10 +4,28 @@ A Julia Kubernetes Client. -An easy to use API to access Kubernetes clusters from Julia. The `Kuber.ApiImpl.Kubernetes` submodule has the complete set of low level APIs and entities. +An easy to use API to access Kubernetes clusters from Julia. Under the verb API sits a complete generated client: one module per Kubernetes API group version in `Kuber.ApiImpl` (`K8sV1`, `K8sAppsV1`, `K8sBatchV1`, …), with every low level operation and model type. [Supported API Versions](SupportedAPIVersions.md) +> ### ⚠ This is the `openapi-v1-trial` branch +> +> A trial rebuild of Kuber on [OpenAPI.jl 1.0](https://github.com/JuliaComputing/OpenAPI.jl/pull/103), pinned to an unmerged commit. See [the trial plan](OpenAPIv1TrialBranchPlan.md) and [the evaluation notes](OpenAPIv1RewriteNotes.md). Requires **Julia 1.11+**, HTTP.jl 2.x and JSON.jl 1.7+. +> +> What changes for callers of the verb API: +> +> - **Absent fields are `ABSENT`, not `nothing`.** This is the one semantic change to watch for. A field missing from the payload now reads as `OpenAPI.Runtime.ABSENT`, and `nothing` means an explicit JSON `null`. Code doing `x.field === nothing` to test "not set" must use `Kuber._field(x.field) === nothing` (or compare against `ABSENT`) instead. +> - **Model field names are lowercase**, with a `_` suffix where a name collided: `metadata.resourceversion`, `obj.apiversion`. Type names are unchanged (`IoK8sApiCoreV1Pod`). +> - **String maps are open objects, not `Dict`s.** `metadata.labels`, `metadata.annotations` and friends get a generated struct whose entries live in `additional_properties`. Use `kuber_props(pod.metadata.annotations)["key"]` rather than indexing the field. +> - **`OpenAPI.Clients.getpropertyat`/`haspropertyat` have replacements**: `Kuber.getpropertyat(pod, :spec, :containers, 1, :image)` and `Kuber.haspropertyat`. Unexported, so qualify them. They treat `ABSENT` as absent — which a handwritten `hasproperty` walk cannot, since on 1.0 every field exists — and a path element may name an open-struct entry, so `Kuber.getpropertyat(node, :metadata, :labels, "role")` reads a label directly. Paths use the generated (lowercase) field names, and case is not folded. +> - **Watch events are `KuberEvent`**, with `event.type` and an already-typed `event.object` — `kuber_obj(ctx, event.object)` is no longer needed (it still accepts a dict). The first item on the stream is still the initial typed list result. +> - **Every group module has its own copy of the shared meta types**, so a `Status` from `apps/v1` is not the same Julia type as core's. Compare `kuber_kind(result) == "Status"` rather than the type — this matters for `delete!`, which returns either the deleted object or a `Status`. +> - **Timeouts are HTTP.jl 2.x request options.** `set_timeout(ctx, secs)` now sets `request_timeout`; `set_request_options(ctx; ...)` passes anything else through (including TLS configuration). Watches never carry an overall deadline — bound them with `timeout_seconds` instead. +> - **Errors** are always `KuberException`; there are no `(result, response)` tuples to check. +> - **Aggregated APIs are captured from a cluster, not from release specs.** `metrics.k8s.io/v1beta1` is captured and shipped, so `:NodeMetrics`/`:PodMetrics` work against metrics-server. `custom.metrics.k8s.io` was captured from a real adapter and deliberately not shipped (`OpenAPIv1ConsumerGaps.md` C5), so the `list_custom_metrics`/`list_namespaced_custom_metrics` helpers, which are implemented, need the group registered first. CRD-backed groups stay out: they belong to the deployment that defines them. The generated layer covers the group versions listed in `gen/openapi_v1/fetch_specs.sh` plus the captures in `SPECS_CAPTURED`. +> +> The generated layer is checked in and reproducible; see [`gen/openapi_v1/README.md`](gen/openapi_v1/README.md) to regenerate it. Never hand-edit `src/ApiImpl/generated/`. + Most of the low level APIs fit into a common usage pattern. Kuber.jl makes it possible to use all of them with only a few intuitive verb based APIs. Verbs act on entities. Entities can be identified by names or selector patterns, or otherwise can apply to all entities of that class. Verbs can take additional parameters, e.g. when creating or updating entities. API and Entity naming convention follows the standard Kubernetes API and Model naming conventions. @@ -47,10 +65,10 @@ All verbs have the signature: verb(ctx::KuberContext, T::Symbol, args...; kwargs...) ``` -Kubernetes also provides efficient change notifications on resources via "watches". Certain entities have the special `watch` APIs defined for them and that can be invoked with the `watch` verb. The `watch` API accepts a `Channel` through which it streams events. +Kubernetes also provides efficient change notifications on resources via "watches". These can be invoked with the `watch` verb, which accepts a `Channel` through which it streams events. ```julia -watch(ctx::KuberContext, T::Symbol, outstream::Channel, args...; kwargs...) +watch(ctx::KuberContext, T::Symbol, outstream::Channel; kwargs...) ``` In addition, verbs like `get` and `list` also support watches, and those can be invoked as: @@ -65,27 +83,86 @@ end E.g.: +E.g.: + ```julia -watch(ctx, list, :Pod; resource_version=19451) do stream +watch(ctx, list, :Pod) do stream for event in stream - @info("got event", event) + @info("got event", event) # a PodList first, then KuberEvents end end ``` +The watch keeps itself alive: if the connection ends or is dropped, it is +re-established from the last `resourceVersion` seen. Closing the stream is how a +consumer stops a watch. + +**A list object on the stream means complete current state.** It is the first +frame, and it appears again whenever the watch has to resync. That happens when +the `resourceVersion` expires — the apiserver answers a watch resumed from too +old a version with an in-stream `ERROR`, and Kuber lists again rather than +watching from scratch. Watching from scratch would replay everything that +currently exists as `ADDED` and never mention what was *deleted* while the watch +was gone, so a consumer's cache would keep phantom entries for the life of the +process. So: on a list frame, discard anything you cached that is not in it. + +`watch(ctx, :Pod, stream)` — the events-only form — opts out of list frames, and +therefore out of resync state too. It still recovers, but a consumer maintaining +a cache on that form has to track expiry itself. + +It also starts from a `resourceVersion` it finds by listing and then discarding +the result, so an object created between the call and that internal list is +never announced. Pass `resource_version=` — read off a `get`/`list` you make +yourself — when there must be no gap between the state you have and the events +you get. That is the list-then-watch shape, and it is what `watch(ctx, list, O)` +does for you. + ### Helper methods: A Kubernetes context can be manipulated with: - `set_server`: Set the API server location ("http://localhost:8001" if not set) - `set_ns`: Set the namespace to deal with (`default` namespace is not set) -- `set_retries`: Set the number of times an API call should be retried on a retriable error (5 if not set) and whether all APIs should be retried (only non mutating APIs are retried by default) +- `set_retries`: Set how many **attempts** an API call gets on a retriable error (5 if not set, so up to four retries) and whether all APIs should be retried (only non mutating APIs are retried by default — with the count meaning attempts, that now genuinely means one request). The count is a budget of requests: HTTP.jl's own retry layer is off by default on a `KuberContext`, so nothing retries underneath it. A retriable error is a transport failure or a 429/5xx; a 429's `Retry-After` lengthens the wait +- `set_timeout` / `get_timeout` / `with_timeout`: Set an overall per-request deadline in seconds +- `set_request_options` / `get_request_options`: Pass any other HTTP.jl request option (connection timeouts, TLS configuration, …) Other convenience methods: -- `kuber_type`: identify the Julia object corresponding to the Kubernetes specification -- `kuber_obj`: instantiate a Julia object from for the supplied Kubernetes specification -- Helper methods for [accessing metrics](Metrics.md) +- `kuber_type`: identify the Julia type corresponding to a Kubernetes payload +- `kuber_obj`: instantiate a Julia object from the supplied Kubernetes specification +- `is_retryable`: whether a failure was transient — the classification Kuber's own retries use, for calls a consumer drives itself. Replaces `OpenAPI.Clients.is_request_interrupted` +- `Kuber.getpropertyat` / `Kuber.haspropertyat`: walk a path of field names, vector indices and open-struct keys, treating `ABSENT` as absent. Unexported replacements for the `OpenAPI.Clients` accessors +- `kuber_kind`: the Kubernetes kind of an object, read off the value rather than its type +- `kind_to_type`: the Julia type for a kind, optionally in a specific API version +- Helper methods for [accessing metrics](Metrics.md) (not available in this trial branch) + +### Adding API groups Kuber does not ship: + +Kuber ships generated clients for the API groups in a Kubernetes release's own +OpenAPI documents. Aggregated APIs (`metrics.k8s.io`), CRD-backed groups and +anything else specific to a cluster are not in there, and are plugged in at load +time instead: + +```julia +module MyK8sGroups +using Kuber + +include("K8sMetricsK8sIoV1beta1.jl") # the generated group modules +include("registry.jl") # generated: the six tables, which refer + # to those modules by name + +__init__() = Kuber.register!(@__MODULE__) +end +``` + +`Kuber.register!` merges a generated layer's tables into Kuber's registry, after +which its kinds work with the ordinary verbs. It has to be called from +`__init__` — mutations made during precompilation do not persist — and it +validates the whole registration before merging any of it, so a rejected one +changes nothing. `Kuber.unregister!` undoes it. See the `Kuber.register!` +docstring for the table shapes and for how a kind name served by two groups +resolves. ### References: - API conventions: https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md diff --git a/SupportedAPIVersions.md b/SupportedAPIVersions.md index 8d9e5e9a..64c5194b 100644 --- a/SupportedAPIVersions.md +++ b/SupportedAPIVersions.md @@ -1,77 +1,70 @@ ## Supported API Versions -The default API client included in this version of Kuber.jl supports the following API versions: +The generated client included in this version of Kuber.jl covers the following +Kubernetes API group versions, one module each: -- `admissionregistration` -- `admissionregistration_v1` -- `admissionregistration_v1beta1` -- `apiextensions` -- `apiextensions_v1` -- `apiextensions_v1beta1` -- `apiregistration` -- `apiregistration_v1` -- `apiregistration_v1beta1` -- `apis` -- `apps` -- `apps_v1` -- `apps_v1beta1` -- `apps_v1beta2` -- `auditregistration` -- `auditregistration_v1alpha1` -- `authentication` -- `authentication_v1` -- `authentication_v1beta1` -- `authorization` -- `authorization_v1` -- `authorization_v1beta1` -- `autoscaling` -- `autoscaling_v1` -- `autoscaling_v2beta1` -- `autoscaling_v2beta2` -- `batch` -- `batch_v1` -- `batch_v1beta1` -- `batch_v2alpha1` -- `certificates` -- `certificates_v1beta1` -- `coordination` -- `coordination_v1` -- `coordination_v1beta1` -- `core` -- `core_v1` -- `custom_metrics_v1beta1` -- `discovery` -- `discovery_v1beta1` -- `events` -- `events_v1beta1` -- `extensions` -- `extensions_v1beta1` -- `flowcontrolApiserver` -- `flowcontrolApiserver_v1alpha1` -- `karpenterSh_v1alpha5` -- `logs` -- `metrics_v1beta1` -- `networking` -- `networking_v1` -- `networking_v1beta1` -- `node` -- `node_v1alpha1` -- `node_v1beta1` -- `policy` -- `policy_v1beta1` -- `rbacAuthorization` -- `rbacAuthorization_v1` -- `rbacAuthorization_v1alpha1` -- `rbacAuthorization_v1beta1` -- `scheduling` -- `scheduling_v1` -- `scheduling_v1alpha1` -- `scheduling_v1beta1` -- `settings` -- `settings_v1alpha1` -- `storage` -- `storage_v1` -- `storage_v1alpha1` -- `storage_v1beta1` -- `version` +| Group version | Module | +| --- | --- | +| `v1` (core) | `K8sV1` | +| `apiextensions.k8s.io/v1` | `K8sApiextensionsK8sIoV1` | +| `apiregistration.k8s.io/v1` | `K8sApiregistrationK8sIoV1` | +| `apps/v1` | `K8sAppsV1` | +| `autoscaling/v1` | `K8sAutoscalingV1` | +| `autoscaling/v2` | `K8sAutoscalingV2` | +| `batch/v1` | `K8sBatchV1` | +| `certificates.k8s.io/v1` | `K8sCertificatesK8sIoV1` | +| `coordination.k8s.io/v1` | `K8sCoordinationK8sIoV1` | +| `discovery.k8s.io/v1` | `K8sDiscoveryK8sIoV1` | +| `events.k8s.io/v1` | `K8sEventsK8sIoV1` | +| `metrics.k8s.io/v1beta1` | `K8sMetricsK8sIoV1beta1` | +| `networking.k8s.io/v1` | `K8sNetworkingK8sIoV1` | +| `node.k8s.io/v1` | `K8sNodeK8sIoV1` | +| `policy/v1` | `K8sPolicyV1` | +| `rbac.authorization.k8s.io/v1` | `K8sRbacAuthorizationK8sIoV1` | +| `scheduling.k8s.io/v1` | `K8sSchedulingK8sIoV1` | +| `storage.k8s.io/v1` | `K8sStorageK8sIoV1` | +Generated from the OpenAPI v3 documents of **Kubernetes v1.35.4** — see +`gen/openapi_v1/specs/SPECS_ORIGIN` for the exact source and checksums. + +`metrics.k8s.io/v1beta1` is the exception: it is served by metrics-server rather +than by the apiserver, so it is absent from the release-tag documents and was +captured from a live cluster instead (`gen/openapi_v1/specs/SPECS_CAPTURED`). +Its kinds are only addressable against a cluster that runs metrics-server. + +API groups that are not here can be captured the same way and plugged in with +`Kuber.register!` without modifying Kuber; see the README. That includes +`custom.metrics.k8s.io`, which was captured and evaluated on 2026-08-15 and +deliberately left out — see `OpenAPIv1ConsumerGaps.md` C5 for what the document +turned out to look like. + +Kubernetes schemas do not close their objects, so a client generated for one +minor tolerates fields *added* by a later server; only contract violations +(nulls where the document promises a value, changed shapes) bite, and GA APIs +rarely do that. Discovery skips any group version the server reports that is not +in the table above, with an informational log line under `verbose=true`. + +`Kuber.ApiImpl.GROUP_MODULES` is this table at runtime. + +### Not included + +- **CRD-backed groups**, which belong to the deployment that defines them and are + registered with `Kuber.register!` rather than shipped here. +- **`custom.metrics.k8s.io`** — captured from a real adapter on 2026-08-15 and + left out on the evidence: its operations carry neither + `x-kubernetes-group-version-kind` nor `x-kubernetes-action`, and address + metrics through a three-variable path, so neither the registry emitter nor the + verb API can carry them without new work, and nothing in the consumer repos + calls the API. See + `OpenAPIv1ConsumerGaps.md` C5, and `gen/openapi_v1/reference-captures/` for the + document itself. The helpers `list_custom_metrics` / + `list_namespaced_custom_metrics` are implemented and exported, and resolve + `:MetricValue` against a group registered with `Kuber.register!`. +- Group versions no longer served by a modern API server (the `*beta*` and + `*alpha*` variants of apps, batch, extensions, settings, auditregistration and + so on, which the 0.2.x client shipped). + +### Adding a group + +Append it to `K8S_GROUPS` in `gen/openapi_v1/fetch_specs.sh` and rerun the +generation chain (`gen/openapi_v1/README.md`). Keep this file in sync. diff --git a/WalkThrough.md b/WalkThrough.md index 2cd2b55b..b51dd7fb 100644 --- a/WalkThrough.md +++ b/WalkThrough.md @@ -1,3 +1,10 @@ +> **Note for the `openapi-v1-trial` branch:** this tutorial still reads as +> written, but three details of the model layer changed — generated field names +> are lowercase (`status.loadbalancer`, not `status.loadBalancer`), a field +> missing from a payload reads as `ABSENT` rather than `nothing` (use +> `Kuber._field`), and string maps like `metadata.labels` need `kuber_props`. +> See the README for the full list. + Kubernetes is an open-source container-orchestration system for deployment, scaling and management of containerized applications. Widespread adoption of Kubernetes allows freedom of deploying applications on-premises, on public cloud, or on a hybrid infrastructure. The Julia package Kuber.jl makes Kubernetes clusters easy to use and plug in to from Julia code. @@ -326,8 +333,10 @@ julia> while true println("waiting for loadbalancer to be configured...") sleep(30) status = get(ctx, :Service, "nginx-service").status - if nothing !== status.loadBalancer.ingress && !isempty(status.loadBalancer.ingress) - println(status.loadBalancer.ingress[1].ip) + # lowercase field names, and `_field` because an unset field is ABSENT + ingress = Kuber._field(Kuber._field(status.loadbalancer).ingress) + if ingress !== nothing && !isempty(ingress) + println(ingress[1].ip) return end end diff --git a/gen/openapi_v1/README.md b/gen/openapi_v1/README.md new file mode 100644 index 00000000..23ba7489 --- /dev/null +++ b/gen/openapi_v1/README.md @@ -0,0 +1,102 @@ +# Generation pipeline (OpenAPI.jl 1.0 trial) + +Everything in `src/ApiImpl/generated/` is produced here. Never hand-edit that +tree: regenerate instead. Generated output is byte-stable only for the pinned +OpenAPI.jl commit (`[sources]` in `Project.toml`), so **a pin move means +rerunning the whole chain**. + +This replaces the old Java `openapi-generator` flow (`gen/generate.sh`, +`gen/detect_apis_and_types.jl`, `gen/spec/`), which produced the 0.2.x-era +`src/ApiImpl/api` tree and no longer applies. The legacy `gen/spec/` documents +are Swagger 2.0 and are not reusable: the new generator reads OAS 3.0/3.1/3.2 +only. + +## The chain + +```sh +# 1. fetch pristine group documents from a kubernetes/kubernetes release tag +./gen/openapi_v1/fetch_specs.sh v1.35.4 +# …and capture what a release tag cannot carry, from a cluster that serves it +./gen/openapi_v1/fetch_specs.sh --from-cluster metrics.k8s.io/v1beta1 + +# 2. patch them (nullable Time/MicroTime/arrays — see patch_k8s_spec.jq) +for f in gen/openapi_v1/specs/*.json; do + case "$f" in *_patched.json) continue;; esac + jq -f gen/openapi_v1/patch_k8s_spec.jq "$f" > "${f%.json}_patched.json" +done + +# 3. generate one client module per patched document (~30 s, strict mode) +julia --project gen/openapi_v1/generate.jl + +# 4. emit the registry tables (~100 s; plans the documents a second time) +julia --project gen/openapi_v1/emit_registry.jl + +# 5. gate: the registry loads and every entry in it resolves +julia --project test/registry.jl +``` + +Steps 3 and 4 each run the planner over all 18 documents, which is why step 4 +costs about as much as step 3 twice over. That is deliberate: the registry +reads generated identifiers off the planner instead of reimplementing its +naming rules, and the two passes are deterministic for a pinned commit. A +drift between them shows up immediately in step 5 as an `UndefVarError`. + +## What is checked in, and why + +The pristine specs, the patched specs, `SPECS_ORIGIN`/`SPECS_CAPTURED`, and the +generated modules are all committed. Together they make the generated layer reproducible +and auditable — a reviewer can rerun fetch → patch → generate and get the same +tree — and nothing is generated at install time. + +## Adding an API group + +Append it to `K8S_GROUPS` in `fetch_specs.sh`, then rerun the chain. The group +set is currently the minimum the test suite needs; generating a subset keeps +the checked-in module size down (~18 MiB for 18 groups). That figure was +~24 MiB before patch rule §7 collapsed the `allOf` wrappers, which halved the +generated type count (2252 → 1098). + +Two things upstream release tags do not carry, because they are not part of +Kubernetes: aggregated APIs (`metrics.k8s.io` is served by metrics-server, +`custom.metrics.k8s.io` by an adapter) and CRD-backed groups. A live apiserver +serves a real OpenAPI 3.0.0 document for each of them at +`/openapi/v3/apis//`, so `fetch_specs.sh --from-cluster` is the +second source mode. Its provenance lands in `SPECS_CAPTURED` rather than +`SPECS_ORIGIN` — separate files, so neither mode clobbers the other's record, +and because a captured document is only as reproducible as the cluster it came +from, which is worth stating plainly. `SPECS_CAPTURED` holds **one record per +file**, carrying the group version path, the cluster and its version, the date +and the checksum; a capture replaces the records for the files it writes and +leaves the rest alone, so groups captured months apart from different clusters +each keep their own provenance. + +`metrics.k8s.io/v1beta1` is shipped this way. The existing patch rules covered +it unchanged and strict generation passed first time; the only wrinkle was +cosmetic, since the apiserver serves compact JSON and the capture normalizes it +through `jq .` so the two sources diff alike. + +**What to capture is a judgement, not a default.** A group belongs in Kuber when +any user of the API could plausibly have it, and when its *schema* does not vary +with the deployment. metrics-server is near-universal and the 0.2.x line shipped +`metrics.k8s.io`, so it qualifies; a group whose schema *is* the deployment — +operator CRDs — belongs in that deployment's own package instead, registered +through `Kuber.register!` (see the top-level README). Kuber ships to people who +do not have those. + +**Passing that test is necessary, not sufficient.** `custom.metrics.k8s.io` +passes it — every conformant adapter serves the same schemas out of the shared +`custom-metrics-apiserver` library, and what varies is the metric names, which +are path *values* rather than types — and it is still not shipped, because its +operations carry no `x-kubernetes-group-version-kind` (so `emit_registry.jl` +emits no `OPS` entries for them) and address metrics through a three-variable +path the verb API cannot fill. The document is kept under `reference-captures/` +with the full reasoning in `OpenAPIv1ConsumerGaps.md` C5. The generalizable +lesson: read a captured document's *operations*, not just its schemas, before +adding it to the chain. + +## Strict mode stays on + +Strict generation and strict response validation are both non-negotiable for +the trial. A strict-generation failure, or a `SchemaValidationError` against a +real cluster, means the k8s document lies about a field and the fix is a new +rule in `patch_k8s_spec.jq` — never `validate_responses=false`. diff --git a/gen/openapi_v1/emit_registry.jl b/gen/openapi_v1/emit_registry.jl new file mode 100644 index 00000000..cede8d05 --- /dev/null +++ b/gen/openapi_v1/emit_registry.jl @@ -0,0 +1,388 @@ +# Emit src/ApiImpl/generated/registry.jl — the tables that replace the old +# api_typemap.jl / api_versions.jl and the string-munging + `eval` lookups in +# simpleapi.jl. +# +# Run with the trial branch environment activated, after generate.jl: +# julia --project=. gen/openapi_v1/emit_registry.jl +# +# Everything here is derived from the patched spec JSONs, never from parsing +# generated Julia. Four tables (OpenAPIv1TrialBranchPlan.md §2.4): +# +# GROUP_MODULES apiVersion string -> group module +# MODULE_GVS group module -> its own apiVersion string +# KIND_TYPES (apiVersion, kind) -> generated model type +# OPS (module, verb, kind, scope) -> generated operation function +# OP_PARAMS same key -> positional argument names, in call order +# +# Deviations from the plan's sketch, both forced by the spec: +# +# * OPS is keyed by module as well as (verb, kind, scope). The plan's 3-tuple +# cannot express two shipped versions of one kind, and the trial ships two: +# autoscaling/v1 and autoscaling/v2 both define HorizontalPodAutoscaler. +# Callers resolve the module first (apiversion kwarg or ctx.modelapi) exactly +# as before, then index OPS — so the resolution flow is unchanged. +# * OP_PARAMS exists because the generated positional order is path order: +# `readcorev1namespacedpod(namespace, name)` takes the namespace FIRST, and +# bodies come last. Emitting the order keeps simpleapi from re-deriving it. +using JSON + +include(joinpath(@__DIR__, "generate.jl")) # module_name, group_version, patched_specs, OUTDIR + +# k8s x-kubernetes-action -> Kuber verb. `connect` (exec/attach/proxy/…) is out +# of the trial's scope, and `watch` is deliberately excluded: the middle path +# has no /watch/ patch, so nothing in Kuber may reference watch* operationIds +# (trap 8) — watching is `watch=true` on the list op. +const ACTION_VERBS = Dict( + "get" => :get, + "list" => :list, + "post" => :create, + "put" => :replace, + "patch" => :patch, + "delete" => :delete, + "deletecollection" => :deletecollection, +) + +const HTTP_METHODS = ("get", "put", "post", "delete", "options", "head", "patch", "trace") + +const SCHEMA_POINTER = "/components/schemas/" + +""" + model_names(plan) -> Dict{String,String} + +Schema key (`io.k8s.api.core.v1.Pod`) to generated model name +(`IoK8sApiCoreV1Pod`), for the document's top-level component schemas. Read off +the plan rather than derived: see `plan_all`. +""" +function model_names(plan) + names = Dict{String,String}() + for m in plan.models + pointer = string(m.provenance.node.pointer) + startswith(pointer, SCHEMA_POINTER) || continue + key = pointer[length(SCHEMA_POINTER)+1:end] + occursin('/', key) && continue # a nested/projected sub-schema + names[key] = m.name + end + return names +end + +""" + operation_names(plan) -> Dict{String,String} + +`operationId` to generated function name, again read off the plan. +""" +operation_names(plan) = Dict(o.operation.id => o.name for o in plan.operations) + +""" + request_bodies(plan) -> Dict{String,Vector{Pair{String,String}}} + +Per operation with a required body, the generated body type **for each media +type**, in the planner's order. + +One type per media type rather than one per operation: since the json-patch rule +(patch_k8s_spec.jq §6) a PATCH takes `meta.v1.Patch` for four of its media types +and the `meta.v1.JSONPatch` array for the fifth, so `body.type` alone is a +`Union` that cannot tell a caller which shape their `content_type` needs. +""" +function request_bodies(plan) + out = Dict{String,Vector{Pair{String,String}}}() + for o in plan.operations + body = o.request_body + (body === nothing || !body.required) && continue + out[o.operation.id] = Pair{String,String}[String(first(m)) => String(last(m)) + for m in body.media_types] + end + return out +end + +api_version(gvk) = isempty(gvk["group"]) ? gvk["version"] : string(gvk["group"], "/", gvk["version"]) + +path_prefix(gv::AbstractString) = gv == "v1" ? "/api/v1" : "/apis/" * gv + +""" + path_shape(path, prefix) -> (namespaced, plural, has_name, subresource) + +Decompose a k8s path relative to its document's API root. `subresource` holds +the literal segments after `{name}` (templated segments dropped). +""" +function path_shape(path::AbstractString, prefix::AbstractString) + startswith(path, prefix) || return nothing + rest = strip(path[length(prefix)+1:end], '/') + isempty(rest) && return nothing + segs = split(rest, '/') + "watch" in segs && return nothing # deprecated dedicated watch paths + nsidx = findfirst(==("{namespace}"), segs) + namespaced = nsidx !== nothing + resource = namespaced ? segs[nsidx+1:end] : segs + isempty(resource) && return nothing + plural = resource[1] + startswith(plural, "{") && return nothing + has_name = length(resource) >= 2 && resource[2] == "{name}" + sub = has_name ? filter(s -> !startswith(s, "{"), resource[3:end]) : String[] + return (; namespaced, plural, has_name, subresource = sub) +end + +""" + scope_of(shape, operation_id) -> Symbol + +`:namespaced`, `:allns` (a `…ForAllNamespaces` collection op) or `:cluster`. +""" +function scope_of(shape, operation_id::AbstractString) + shape.namespaced && return :namespaced + endswith(operation_id, "ForAllNamespaces") && return :allns + return :cluster +end + +""" + positional_params(path, operation) -> Vector{Symbol} + +Generated operations take path parameters in path order, then a *required* +request body last. An optional body stays a keyword argument — `delete` and +`deletecollection` document an optional `DeleteOptions` body, and their +generated signatures take no positional body. +""" +function positional_params(path::AbstractString, operation) + params = Symbol[Symbol(m.captures[1]) for m in eachmatch(r"\{([^}]+)\}", path)] + body = get(operation, "requestBody", nothing) + body isa AbstractDict && get(body, "required", false) === true && push!(params, :body) + return params +end + +struct Doc + file::String + modname::String + gv::String + json::Dict{String,Any} + models::Dict{String,String} # schema key -> generated model name + operations::Dict{String,String} # operationId -> generated function name + bodies::Dict{String,Vector{Pair{String,String}}} # operationId -> [media type => body type] +end + +function load_docs() + plans = plan_all() + docs = Doc[] + for f in patched_specs() + modname = module_name(f) + plan = plans[modname] + push!(docs, Doc(f, modname, group_version(f), + JSON.parsefile(f; dicttype = Dict{String,Any}), + model_names(plan), operation_names(plan), request_bodies(plan))) + end + return docs +end + +""" + kind_types(docs) -> Dict{Tuple{String,String},Tuple{String,String}} + +`(apiVersion, kind)` -> `(module, generated type name)`, restricted to the +group-versions the trial actually ships. + +Every k8s schema carries `x-kubernetes-group-version-kind`, but the meta types +(`Status`, `DeleteOptions`, `WatchEvent`, `APIResourceList`) are registered +under *every* group-version in *every* document, and each group module has its +own copy of the type — so the table would be `readdir`-order dependent without +a policy. The policy: the module whose own group-version matches the key wins, +then core, then the alphabetically first — deterministic in all three cases. +""" +function kind_types(docs::Vector{Doc}) + shipped = Set(d.gv for d in docs) + candidates = Dict{Tuple{String,String},Vector{Doc}}() + schemas = Dict{Tuple{String,String,String},String}() # (module, apiVersion, kind) -> schema key + for d in docs + for (schema, body) in get(d.json["components"], "schemas", Dict()) + body isa AbstractDict || continue + for gvk in get(body, "x-kubernetes-group-version-kind", ()) + av = api_version(gvk) + av in shipped || continue + key = (av, gvk["kind"]) + push!(get!(candidates, key, Doc[]), d) + schemas[(d.modname, key...)] = schema + end + end + end + out = Dict{Tuple{String,String},Tuple{String,String}}() + for (key, cands) in candidates + av, _ = key + pick = findfirst(d -> d.gv == av, cands) + pick === nothing && (pick = findfirst(d -> d.gv == "v1", cands)) + pick === nothing && (pick = argmin([d.modname for d in cands])) + d = cands[pick] + out[key] = (d.modname, d.models[schemas[(d.modname, key...)]]) + end + return out +end + +""" + ops(docs) -> (ops, params) + +`(module, verb, kind, scope)` -> generated function name, plus the positional +argument names for the same key. + +The kind is *not* the operation's own `x-kubernetes-group-version-kind`: on a +subresource path that extension names the subresource's type +(`pods/{name}/eviction` is `policy/v1 Eviction`, `pods/{name}/exec` is +`PodExecOptions`), which would collide with — or hide — the parent resource. +Instead the parent resource's kind comes from the bare `…/{plural}/{name}` +path, and a subresource gets a synthetic kind of parent + capitalized +subresource: `PodLog`, `PodStatus`, `DeploymentScale`. That reproduces the +operationId tails exactly, and it is how `:PodLog` (§5.4) enters the table +through the generic path rather than as a special case. +""" +function ops(docs::Vector{Doc}) + table = Dict{Tuple{String,Symbol,Symbol,Symbol},String}() + params = Dict{Tuple{String,Symbol,Symbol,Symbol},Vector{Symbol}}() + bodies = Dict{Tuple{String,Symbol,Symbol,Symbol},Vector{Pair{String,String}}}() + for d in docs + prefix = path_prefix(d.gv) + # first pass: the kind behind each (namespaced, plural) resource + resource_kinds = Dict{Tuple{Bool,String},String}() + for (path, item) in d.json["paths"] + shape = path_shape(path, prefix) + shape === nothing && continue + isempty(shape.subresource) || continue + for method in HTTP_METHODS + op = get(item, method, nothing) + op isa AbstractDict || continue + gvk = get(op, "x-kubernetes-group-version-kind", nothing) + gvk === nothing && continue + haskey(ACTION_VERBS, get(op, "x-kubernetes-action", "")) || continue + resource_kinds[(shape.namespaced, shape.plural)] = gvk["kind"] + end + end + # second pass: the operations themselves + for (path, item) in d.json["paths"] + shape = path_shape(path, prefix) + shape === nothing && continue + parent = get(resource_kinds, (shape.namespaced, shape.plural), nothing) + parent === nothing && continue + kind = Symbol(parent * join(uppercasefirst.(shape.subresource))) + for method in HTTP_METHODS + op = get(item, method, nothing) + op isa AbstractDict || continue + verb = get(ACTION_VERBS, get(op, "x-kubernetes-action", ""), nothing) + verb === nothing && continue + opid = op["operationId"] + fname = d.operations[opid] + key = (d.modname, verb, kind, scope_of(shape, opid)) + if haskey(table, key) && table[key] != fname + error("ambiguous operation for $key: $(table[key]) vs $fname") + end + table[key] = fname + params[key] = positional_params(path, op) + haskey(d.bodies, opid) && (bodies[key] = d.bodies[opid]) + end + end + end + return table, params, bodies +end + +sortkey(k::Tuple{String,String}) = k +sortkey(k::Tuple{String,Symbol,Symbol,Symbol}) = (k[1], string(k[2]), string(k[3]), string(k[4])) + +function emit(io::IO, docs::Vector{Doc}) + types = kind_types(docs) + optable, opparams, opbodies = ops(docs) + + println(io, """ + # Generated by gen/openapi_v1/emit_registry.jl from the patched specs in + # gen/openapi_v1/specs. Do not edit — rerun the pipeline instead + # (fetch_specs.sh -> patch_k8s_spec.jq -> generate.jl -> emit_registry.jl). + # + # Kubernetes $(K8S_TAG[]), $(length(docs)) group modules. + """) + + println(io, "\"\"\"\nGroup-version string (a k8s `apiVersion`) to the generated module serving it.\n\"\"\"") + println(io, "const GROUP_MODULES = Dict{String,Module}(") + for d in sort(docs; by = x -> x.gv) + println(io, " ", repr(d.gv), " => ", d.modname, ",") + end + println(io, ")\n") + + println(io, "\"\"\"\nInverse of [`GROUP_MODULES`]: each group module's own `apiVersion`.\n\"\"\"") + println(io, "const MODULE_GVS = Dict{Module,String}(") + for d in sort(docs; by = x -> x.modname) + println(io, " ", d.modname, " => ", repr(d.gv), ",") + end + println(io, ")\n") + + println(io, """ + \"\"\" + `(apiVersion, kind)` to the generated model type, from every schema carrying + `x-kubernetes-group-version-kind`. Replaces the old `Typedefs` aliases and + `kuber_type`'s response sniffing, and gives exactly the addressable kinds + rather than every model a `names()` scan would find. + \"\"\"""") + println(io, "const KIND_TYPES = Dict{Tuple{String,String},Type}(") + for key in sort!(collect(keys(types)); by = sortkey) + mod, T = types[key] + println(io, " (", repr(key[1]), ", ", repr(key[2]), ") => ", mod, ".", T, ",") + end + println(io, ")\n") + + println(io, """ + \"\"\" + `(module, verb, kind, scope)` to the generated operation function, where + `verb ∈ (:get, :list, :create, :replace, :patch, :delete, :deletecollection)` + and `scope ∈ (:namespaced, :cluster, :allns)`. A build-time table: no `eval`, + no `isdefined` probing, and a missing verb/kind is a clean lookup miss. + \"\"\"""") + println(io, "const OPS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}(") + for key in sort!(collect(keys(optable)); by = sortkey) + mod, verb, kind, scope = key + println(io, " (", mod, ", ", repr(verb), ", ", repr(kind), ", ", repr(scope), ") => ", + mod, ".", optable[key], ",") + end + println(io, ")\n") + + println(io, """ + \"\"\" + Positional argument names for each [`OPS`] entry, in call order: path + parameters in path order (namespace before name), then `:body`. + \"\"\"""") + println(io, "const OP_PARAMS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}(") + for key in sort!(collect(keys(opparams)); by = sortkey) + mod, verb, kind, scope = key + println(io, " (", mod, ", ", repr(verb), ", ", repr(kind), ", ", repr(scope), ") => ", + repr(opparams[key]), ",") + end + println(io, ")\n") + + println(io, """ + \"\"\" + For each [`OPS`] entry with a required request body, the media types the + document accepts and the generated body type for each. + + `update!` needs the mapping, not just a list: a PATCH takes the `Patch` model + (an open object) for merge, strategic-merge and apply patches, but the + `JSONPatch` array for `application/json-patch+json` — one schema per media + type since patch_k8s_spec.jq §6. It is also what lets a wrong `content_type` + be reported as such — k8s documents no plain `application/json` for a PATCH — + instead of failing deep inside media selection. + \"\"\"""") + println(io, "const OP_BODIES = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}(") + for key in sort!(collect(keys(opbodies)); by = sortkey) + mod, verb, kind, scope = key + media = opbodies[key] + entries = join(("$(repr(m)) => $mod.$T" for (m, T) in media), ", ") + println(io, " (", mod, ", ", repr(verb), ", ", repr(kind), ", ", repr(scope), ") => ", + "Dict{String,Type}(", entries, "),") + end + println(io, ")") + return length(types), length(optable) +end + +const K8S_TAG = Ref("unknown") + +function main() + origin = joinpath(SPECDIR, "SPECS_ORIGIN") + if isfile(origin) + m = match(r"tag (\S+)", readline(origin)) + m === nothing || (K8S_TAG[] = m.captures[1]) + end + docs = load_docs() + out = joinpath(OUTDIR, "registry.jl") + ntypes, nops = open(io -> emit(io, docs), out, "w") + @info "emitted registry.jl" modules = length(docs) kinds = ntypes operations = nops KiB = + round(filesize(out) / 1024; digits = 1) +end + +abspath(PROGRAM_FILE) == (@__FILE__) && main() diff --git a/gen/openapi_v1/fetch_specs.sh b/gen/openapi_v1/fetch_specs.sh new file mode 100755 index 00000000..2394a943 --- /dev/null +++ b/gen/openapi_v1/fetch_specs.sh @@ -0,0 +1,176 @@ +#!/usr/bin/env bash +# Fetch k8s OpenAPI v3 group documents into specs/, from either of two sources. +# +# fetch_specs.sh # e.g. v1.35.4 +# fetch_specs.sh --from-cluster /... # e.g. metrics.k8s.io/v1beta1 +# +# **Release tag** is the source of truth for everything the apiserver itself +# serves: authoritative, reproducible, and decoupled from cluster quirks. One +# file per group lives under api/openapi-spec/v3/ at each tag, named +# apis_____openapi.json (core is api__v1_openapi.json); we +# rename to the pipeline's apis__.json convention. +# +# **A cluster** is the only source for the rest. Aggregated APIs (metrics.k8s.io +# is served by metrics-server, custom.metrics.k8s.io by an adapter) and +# CRD-backed groups are absent from release-tag specs by construction — they are +# not part of Kubernetes. A live apiserver serves a real OpenAPI 3.0.0 document +# for every group version it hosts, aggregated and CRD alike, at +# /openapi/v3/apis//. +# +# The two modes write separate provenance files, so neither clobbers the other's +# record: SPECS_ORIGIN for the tag, SPECS_CAPTURED for the cluster. A captured +# document is only as reproducible as the cluster it came from, which is exactly +# why its provenance is recorded separately and in more detail. SPECS_CAPTURED +# holds one record per file and is merged, not rewritten, so capturing one group +# leaves every other group's record alone. +# +# Adding a group is mechanical either way: append it to K8S_GROUPS below (or +# capture it), then rerun patch (patch_k8s_spec.jq) -> generate.jl -> +# emit_registry.jl. +set -euo pipefail +# SPECS_DIR exists so the capture path can be exercised against a throwaway +# directory; everything real uses the default. +DEST="${SPECS_DIR:-$(dirname "$0")/specs}" +mkdir -p "$DEST" + +usage() { + echo "usage: fetch_specs.sh " >&2 + echo " fetch_specs.sh --from-cluster /... [KUBECTL=kubectl]" >&2 + exit 1 +} + +# ── cluster capture ──────────────────────────────────────────────────────── +if [ "${1:-}" = "--from-cluster" ]; then + shift + [ $# -gt 0 ] || usage + KUBECTL="${KUBECTL:-kubectl}" + PROV="$DEST/SPECS_CAPTURED" + server="$("$KUBECTL" version -o json 2>/dev/null | jq -r '.serverVersion.gitVersion // "unknown"')" + context="$("$KUBECTL" config current-context 2>/dev/null || echo unknown)" + now="$(date -u +%Y-%m-%dT%H:%M:%SZ)" + + newrec="$(mktemp)" + # $tmp has already been moved into place on the success path, so removing it + # here is a no-op; it only matters when a capture died mid-flight. + trap 'rm -f "$newrec" "${tmp:-}"' EXIT + names="" + for gv in "$@"; do + case "$gv" in + */*) ;; + *) echo "expected /, got '$gv'" >&2; exit 1;; + esac + name="apis_${gv%/*}_${gv#*/}.json" + out="$DEST/$name" + echo "capturing $gv -> $out" + # jq . normalizes the apiserver's compact JSON to the same shape the + # fetched documents have, so the two sources diff alike. Through a temp + # file, so a failed capture cannot leave a truncated document behind: + # the redirect would have emptied the old one before kubectl was known + # to have failed. + tmp="$(mktemp "$DEST/.$name.XXXXXX")" + if ! "$KUBECTL" get --raw "/openapi/v3/apis/$gv" | jq . > "$tmp"; then + rm -f "$tmp" + echo "capture failed for $gv — $out left as it was" >&2 + exit 1 + fi + mv "$tmp" "$out" + { + echo "file: $name" + echo "path: /openapi/v3/apis/$gv" + echo "server: $server" + echo "context: $context" + echo "captured: $now" + echo "sha256: $(sha256sum < "$out" | cut -d' ' -f1)" + echo "" + } >> "$newrec" + names="$names $name" + done + + # Merge, do not overwrite. Each capture owns the records for the files it + # just wrote and leaves every other record alone, so groups captured at + # different times from different clusters keep their own provenance. This + # replaced a plain `>`, under which a second single-group capture silently + # erased the first group's record — in the one file whose entire job is to + # remember where a document came from. + kept="" + if [ -f "$PROV" ]; then + kept="$(awk -v drop="$names" ' + BEGIN { RS = ""; n = split(drop, a, " "); for (i = 1; i <= n; i++) d[a[i]] = 1 } + /^#/ { next } + { + f = "" + split($0, lines, "\n") + for (i in lines) if (lines[i] ~ /^file:[ \t]+/) { f = lines[i]; sub(/^file:[ \t]+/, "", f) } + if (f in d) next # this run rewrites it + # A block with no file: line is not a record this script wrote. + # Keep it verbatim and say so: dropping it would be the same + # silent provenance loss this merge exists to prevent. + if (f == "") print "SPECS_CAPTURED: keeping an unrecognized block verbatim" > "/dev/stderr" + printf "%s\n\n", $0 + }' "$PROV")" + fi + + { + cat <<'HDR' +# Provenance for documents captured from a live cluster: aggregated APIs +# (metrics.k8s.io and the like) and CRD-backed groups, which release-tag specs +# do not carry. Kept apart from SPECS_ORIGIN because a captured document is only +# as reproducible as the cluster it came from. +# +# One record per file. Re-capturing a file replaces its record and leaves the +# others alone. +HDR + echo "" + if [ -n "$kept" ]; then printf '%s\n\n' "$kept"; fi + cat "$newrec" + } > "$PROV.new" + # Command substitution eats trailing newlines, which is the point. + printf '%s\n' "$(cat "$PROV.new")" > "$PROV" + rm -f "$PROV.new" + exit 0 +fi + +# ── upstream release tag ─────────────────────────────────────────────────── +K8S_TAG="${1:-}" +[ -n "$K8S_TAG" ] || usage +BASE="https://raw.githubusercontent.com/kubernetes/kubernetes/${K8S_TAG}/api/openapi-spec/v3" + +# core, then the trial's group set — the minimum set for the existing test +# suite. Generating a subset keeps the checked-in module size down (core v1 +# alone is ~6.7 MiB of generated Julia). +K8S_GROUPS=" +api__v1 +apis__apps__v1 +apis__batch__v1 +apis__autoscaling__v1 +apis__autoscaling__v2 +apis__rbac.authorization.k8s.io__v1 +apis__networking.k8s.io__v1 +apis__storage.k8s.io__v1 +apis__policy__v1 +apis__events.k8s.io__v1 +apis__scheduling.k8s.io__v1 +apis__coordination.k8s.io__v1 +apis__certificates.k8s.io__v1 +apis__discovery.k8s.io__v1 +apis__node.k8s.io__v1 +apis__apiextensions.k8s.io__v1 +apis__apiregistration.k8s.io__v1 +" + +fetched="" +for g in $K8S_GROUPS; do + out="$DEST/$(echo "$g" | sed 's/__/_/g').json" + echo "fetching $g -> $out" + curl -fsSL -o "$out" "$BASE/${g}_openapi.json" + fetched="$fetched $(basename "$out")" +done + +# record provenance next to the specs, for the files this mode owns only +{ + echo "source: https://github.com/kubernetes/kubernetes tag ${K8S_TAG}" + echo "path: api/openapi-spec/v3/" + echo "fetched: $(date -u +%Y-%m-%dT%H:%M:%SZ)" + echo "files:" + (cd "$DEST" && sha256sum $fetched) +} > "$DEST/SPECS_ORIGIN" diff --git a/gen/openapi_v1/generate.jl b/gen/openapi_v1/generate.jl new file mode 100644 index 00000000..44d344ab --- /dev/null +++ b/gen/openapi_v1/generate.jl @@ -0,0 +1,91 @@ +# Generate one Julia client module per patched k8s group document. +# +# Run with the trial branch environment activated: +# julia --project=. gen/openapi_v1/generate.jl +# +# Strict generation is the default and must stay on: a strict-generation +# failure means the patch list (patch_k8s_spec.jq) needs a new rule — that is +# signal, not noise. `datetime` is left at the generator default `:utc`, which +# matches k8s (all timestamps are UTC) and keeps TimeZones.jl out of the +# dependency set. +# +# Module naming: strip the `apis?_` filename prefix, split on `.`/`_`, +# camel-case each part, prefix `K8s`: +# api_v1 -> K8sV1 +# apis_apps_v1 -> K8sAppsV1 +# apis_rbac.authorization.k8s.io_v1 -> K8sRbacAuthorizationK8sIoV1 +# +# Never hand-edit the output: generated code is byte-stable only per pinned +# OpenAPI commit, so regenerate whenever the pin moves. +using OpenAPI, HTTP + +const SPECDIR = joinpath(@__DIR__, "specs") +const OUTDIR = joinpath(@__DIR__, "..", "..", "src", "ApiImpl", "generated") + +""" + module_name(specfile) -> String + +The generated module name for a patched spec file, per the convention above. +Shared with emit_registry.jl. +""" +function module_name(specfile::AbstractString) + base = replace(basename(specfile), "_patched.json" => "", ".json" => "") + base = replace(base, r"^apis?_" => "") + "K8s" * join(uppercasefirst.(split(replace(base, "." => "_"), "_"))) +end + +""" + group_version(specfile) -> String + +The k8s `apiVersion` string a spec file describes: `api_v1` -> `"v1"`, +`apis_apps_v1` -> `"apps/v1"`. +""" +function group_version(specfile::AbstractString) + base = replace(basename(specfile), "_patched.json" => "", ".json" => "") + startswith(base, "apis_") || return replace(base, "api_" => "") + parts = split(base[6:end], "_") + string(join(parts[1:end-1], "_"), "/", parts[end]) +end + +function patched_specs() + specs = sort(filter(endswith("_patched.json"), readdir(SPECDIR; join = true))) + isempty(specs) && error("no patched specs in $SPECDIR — run fetch_specs.sh then patch_k8s_spec.jq") + return specs +end + +""" + plan_all() -> Dict{String,OpenAPI.ClientPlan} + +Plan every patched spec, keyed by module name. `emit_registry.jl` reads the +generated model and operation identifiers off these plans rather than +recomputing them: the planner's naming rules are not a simple transformation +(they normalize non-identifier characters, dodge Base/Core and reserved names, +and disambiguate collisions with a counter), so any reimplementation would +drift silently. Planning is deterministic for a pinned OpenAPI commit, and a +drift between this pass and generation's would surface as an `UndefVarError` +the moment the registry loads. +""" +function plan_all() + plans = Dict{String,OpenAPI.ClientPlan}() + for f in patched_specs() + modname = module_name(f) + plans[modname] = OpenAPI.plan(f; name = modname) + end + return plans +end + +function main() + mkpath(OUTDIR) + total = 0.0 + for f in patched_specs() + modname = module_name(f) + out = joinpath(OUTDIR, "$(modname).jl") + t = @elapsed OpenAPI.client(f; name = modname, path = out) + total += t + @info "generated $modname" group_version = group_version(f) seconds = round(t; digits = 1) MiB = + round(filesize(out) / 1024^2; digits = 2) + end + @info "generated $(length(patched_specs())) modules" seconds = round(total; digits = 1) +end + +abspath(PROGRAM_FILE) == (@__FILE__) && main() diff --git a/gen/openapi_v1/patch_k8s_spec.jq b/gen/openapi_v1/patch_k8s_spec.jq new file mode 100644 index 00000000..5b6e72a1 --- /dev/null +++ b/gen/openapi_v1/patch_k8s_spec.jq @@ -0,0 +1,133 @@ +# Spec patch for the trial's generation pipeline — the "middle path" of +# OpenAPIv1TrialBranchPlan.md §2.2: nullable rules only, no /watch/ path +# rewriting. Watching goes through the regular list operations with +# `watch=true` plus an accept-scoped codec (§4.5), so the deprecated /watch/ +# paths — and the 70-path rewrite the prototype needed for them — are not +# involved. +# +# Every rule is guarded, so the patch applies cleanly to documents that lack +# the schema (including CRD-backed group documents). +# +# 1. meta.v1.Time nullable — wire: "lastProbeTime": null +# 2. meta.v1.MicroTime nullable — wire: "eventTime": null +# 3. every array-typed property nullable: Go marshals nil slices as JSON null, +# so ANY array can arrive null even when the spec calls it required +# (seen live: CSINodeSpec.drivers on storage.k8s.io/v1) +# 4. request bodies documented as `*/*` become `application/json`. k8s declares +# `*/*` for every create/replace body (and for the optional DeleteOptions +# body), which is not a media type a client can encode to: the runtime has no +# `*/*` encoder and would send `Content-Type: */*` even if it did. We always +# send JSON, and k8s always accepts it, so saying so makes the document true. +# Patch bodies are untouched — those name their five media types explicitly. +# 5. DELETE 2xx response schemas become the empty schema (anything). k8s +# documents `Status`, but a delete usually answers with the deleted object +# instead (verified live: deleting a Job returns the Job), so strict decoding +# against `Status` fails on `/status` — an object where Status wants a string. +# This is the lie the old client's get_return_type payload sniffing hid. +# `oneOf: [Status, resource]` was tried and rejected: the generator emits one +# wrapper type per response code per media type (eight for a single delete). +# The empty schema says what is actually true — we do not know which of two +# shapes will arrive — and Kuber restores the type from the payload's +# kind/apiVersion through KIND_TYPES, the same second-stage decode watch +# frames use. Strict validation stays on everywhere. +# 6. `application/json-patch+json` request bodies become an array. k8s documents +# ONE schema — meta.v1.Patch, `type: object` — for all five patch media types, +# but a JSON Patch body is an array of operations (RFC 6902), never an object. +# The generated Patch model can only hold an object, so every consumer that +# patches with `[Dict("op" => "replace", …)]` — which is every json-patch +# caller in JuliaRun and JobLoops — failed to encode. The array is declared +# once as a component (meta.v1.JSONPatch) and referenced, rather than inlined +# per operation: inlining makes the generator emit one item type per patch +# operation (132 of them in apps/v1 alone, +27 KiB), the shared component +# emits one (+3.4 KiB). Items stay `type: object` with no required keys — +# `move`/`copy` use `from`, `remove` has no `value`, so anything stricter +# would reject valid patches under strict request validation. +# 7. `allOf`-wrapped `$ref`s collapse to the `$ref`. k8s never writes a bare +# `$ref` for a property: it wraps it in a single-element `allOf` so it can +# hang a `description` (and often `default: {}`) beside it, because a `$ref` +# with siblings is undefined in OAS 3.0. The generator reads that wrapper as +# a *new* schema and mints a type for it, named after its position — so +# `Pod.spec` was `IoK8sApiCoreV1PodSpec2` (the `2` disambiguating it from the +# real `PodSpec`, which nothing referenced), every kind had its own +# `…Metadata` instead of the shared `ObjectMeta`, and every `…List.items` had +# its own element type instead of the kind's own — `PodList.items` was +# `Vector{IoK8sApiCoreV1PodListItemsItem}`, so `item isa +# kind_to_type(ctx, :Pod)` was false (OpenAPIv1ConsumerGaps.md G18). On +# `master` those were all one type, so it was a regression. +# +# 1290 sites across the 18 documents, in exactly two positions: property +# schemas and the `items` of array properties. Both are scoped explicitly +# rather than walked recursively, because `apiextensions`' `JSONSchemaProps` +# describes JSON Schema itself and so has *properties named* `allOf`, +# `nullable` and `items` — a recursive walk rewrites that map and corrupts +# the CRD document. +# +# Guarded on the shape rather than trusting the survey: collapse only a +# single-element `allOf` whose element is a bare `$ref`. A future spec that +# introduces a two-element `allOf`, or a `$ref` carrying siblings inside it, +# is left alone to be noticed rather than silently mangled. No `allOf` in +# either position carries `nullable`, so nothing nullable is dropped by this. +# 8. `resourceVersion` is declared on single-object read operations. k8s +# documents it on every *list* operation and on none of the reads, but the +# apiserver honours it on both — verified live: `GET …/configmaps/x? +# resourceVersion=0` answers 200, and a version the cluster has never reached +# answers 504 "Too large resource version". So a consumer asking for a read +# "not older than" a version it already saw — which is what `K8sReflector` +# does (`K8sReflector.jl:136-141`) — had no parameter to send (G17). +# +# Added only to paths ending in `{name}`: the object read itself, not +# subresources like `pods/log`, where a resource version is meaningless. 31 +# operations in core v1, none of which declared it already. +# +# Held back until G19/G20 were settled, because the natural failure of this +# parameter is a 504 that blocks for the apiserver's wait, and until then the +# retry budget multiplied that by five without `max_tries` bounding it. +# +# Expect this list to grow: a strict-validation failure against a real cluster +# is signal that the spec lies about another field, and the fix is a new rule +# here — never validate_responses=false. +def collapse_allof: + if type == "object" and has("allOf") and (.allOf | type == "array") + and (.allOf | length) == 1 and (.allOf[0] | keys) == ["$ref"] + then {"$ref": .allOf[0]["$ref"]} + else . end; +(if (.components.schemas | has("io.k8s.apimachinery.pkg.apis.meta.v1.Time")) + then .components.schemas."io.k8s.apimachinery.pkg.apis.meta.v1.Time".nullable = true + else . end) +| (if (.components.schemas | has("io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime")) + then .components.schemas."io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime".nullable = true + else . end) +| (.components.schemas[] | objects | .properties // empty | .[] + | objects | select(.type == "array")).nullable = true +| (.paths[]? | objects | .[]? | objects | select(has("requestBody")) | .requestBody + | objects | select(.content | has("*/*")) | .content) + |= with_entries(if .key == "*/*" then .key = "application/json" else . end) +| (if ([.paths[]? | objects | .patch? | objects | .requestBody? | objects + | .content? | objects | has("application/json-patch+json")] | any) + then .components.schemas["io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch"] = + {"description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", "items": {"type": "object"}} + else . end) +| (.paths[]? | objects | .patch? | objects | .requestBody? | objects + | .content? | objects | .["application/json-patch+json"]? | objects | .schema) + = {"$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch"} +| (.components.schemas[]? | objects | .properties? | objects | .[]) |= collapse_allof +| (.components.schemas[]? | objects | .properties? | objects | .[] + | objects | select(.type == "array") | .items?) |= collapse_allof +| reduce (.paths | keys[]) as $p (.; + if (($p | endswith("{name}")) and (.paths[$p] | has("get")) + and ([.paths[$p].get.parameters[]?.name] | index("resourceVersion") | not)) + then .paths[$p].get.parameters = ((.paths[$p].get.parameters // []) + [{ + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": {"type": "string", "uniqueItems": true}}]) + else . end) +| reduce (.paths | keys[]) as $p (.; + if (.paths[$p] | has("delete")) + then reduce (.paths[$p].delete.responses | to_entries[] + | select(.key | startswith("2")) | .key) as $c (.; + if (.paths[$p].delete.responses[$c] | has("content")) + then (.paths[$p].delete.responses[$c].content) |= with_entries(.value.schema = {}) + else . end) + else . end) diff --git a/gen/openapi_v1/reference-captures/README.md b/gen/openapi_v1/reference-captures/README.md new file mode 100644 index 00000000..6f170ba3 --- /dev/null +++ b/gen/openapi_v1/reference-captures/README.md @@ -0,0 +1,31 @@ +# Reference captures — evidence, not pipeline input + +These documents are **not** sources for the generation chain. Nothing here is +patched, generated or registered, and `specs/` is deliberately the only directory +`fetch_specs.sh`, `patch_k8s_spec.jq` and `generate.jl` read. A document lands +here when it was captured to answer a question rather than to ship a group, and +it stays so the answer can be re-checked without standing the cluster back up. + +## `custom.metrics.k8s.io_v1beta1.json` + +Captured 2026-08-15 from `prometheus-adapter` v0.12.0 (chart +`prometheus-community/prometheus-adapter` 5.3.0) on a local k3s v1.35.4, via +`kubectl get --raw /openapi/v3/apis/custom.metrics.k8s.io/v1beta1 | jq .` — the +same call `fetch_specs.sh --from-cluster` makes. No Prometheus was behind the +adapter, which affects which *metrics* it discovers but not the document: the +schema is static, the resource list is what varies. + +It is here because it decided `OpenAPIv1ConsumerGaps.md` C5, and the answer was +not to ship the group. See C5 for the reasoning; in short, the schemas are the +adapter-independent boilerplate that was predicted, but the *operations* carry no +`x-kubernetes-group-version-kind` and address metrics through a three-variable +path, neither of which the registry emitter or the verb layer can carry today. + +To reproduce or re-check: + +```sh +helm install pa oci://ghcr.io/prometheus-community/charts/prometheus-adapter \ + --namespace custom-metrics --create-namespace --wait +kubectl get --raw /openapi/v3/apis/custom.metrics.k8s.io/v1beta1 | jq . +helm uninstall pa -n custom-metrics && kubectl delete ns custom-metrics +``` diff --git a/gen/openapi_v1/reference-captures/custom.metrics.k8s.io_v1beta1.json b/gen/openapi_v1/reference-captures/custom.metrics.k8s.io_v1beta1.json new file mode 100644 index 00000000..46c5e5a0 --- /dev/null +++ b/gen/openapi_v1/reference-captures/custom.metrics.k8s.io_v1beta1.json @@ -0,0 +1,943 @@ +{ + "openapi": "3.0.0", + "info": { + "title": "prometheus-metrics-adapter", + "version": "1.0.0" + }, + "paths": { + "/apis/custom.metrics.k8s.io/v1beta1/": { + "get": { + "tags": [ + "customMetrics_v1beta1" + ], + "description": "get available resources", + "operationId": "getCustomMetricsV1beta1APIResources", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + } + } + } + } + }, + "/apis/custom.metrics.k8s.io/v1beta1/namespaces/{namespace}/metrics/{name}": { + "get": { + "tags": [ + "customMetrics_v1beta1" + ], + "description": "list custom metrics describing an object or objects", + "operationId": "readCustomMetricsV1beta1MetricValueForNamespace", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + } + } + } + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "metricLabelSelector", + "in": "query", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "name", + "in": "path", + "description": "name of the described resource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/custom.metrics.k8s.io/v1beta1/namespaces/{namespace}/{resource}/{name}/{subresource}": { + "get": { + "tags": [ + "customMetrics_v1beta1" + ], + "description": "list custom metrics describing an object or objects", + "operationId": "listCustomMetricsV1beta1NamespacedMetricValue", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + } + } + } + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "metricLabelSelector", + "in": "query", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "name", + "in": "path", + "description": "name of the described resource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resource", + "in": "path", + "description": "the name of the resource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "subresource", + "in": "path", + "description": "the name of the subresource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/custom.metrics.k8s.io/v1beta1/{resource}/{name}/{subresource}": { + "get": { + "tags": [ + "customMetrics_v1beta1" + ], + "description": "list custom metrics describing an object or objects", + "operationId": "listCustomMetricsV1beta1MetricValue", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList" + } + } + } + } + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "metricLabelSelector", + "in": "query", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "name", + "in": "path", + "description": "name of the described resource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resource", + "in": "path", + "description": "the name of the resource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "subresource", + "in": "path", + "description": "the name of the subresource", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + }, + "components": { + "schemas": { + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "type": "object", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "type": "object", + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string", + "default": "" + }, + "name": { + "description": "name is the plural name of the resource.", + "type": "string", + "default": "" + }, + "namespaced": { + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean", + "default": false + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string", + "default": "" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "type": "array", + "items": { + "type": "string", + "default": "" + } + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "type": "object", + "required": [ + "groupVersion", + "resources" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string", + "default": "" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ] + }, + "x-kubernetes-list-type": "atomic" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "type": "object", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ] + }, + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + } + }, + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "type": "object", + "required": [ + "key", + "operator" + ], + "properties": { + "key": { + "description": "key is the label key that the selector applies to.", + "type": "string", + "default": "" + }, + "operator": { + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string", + "default": "" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "type": "object", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "type": "integer", + "format": "int64" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "type": "string", + "format": "date-time" + }, + "io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValue": { + "description": "MetricValue is a metric value for some object", + "type": "object", + "required": [ + "describedObject", + "metricName", + "timestamp", + "value" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "describedObject": { + "description": "a reference to the described object", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ] + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metricName": { + "description": "the name of the metric", + "type": "string", + "default": "" + }, + "selector": { + "description": "selector represents the label selector that could be used to select this metric, and will generally just be the selector passed in to the query used to fetch this metric. When left blank, only the metric's Name will be used to gather metrics.", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ] + }, + "timestamp": { + "description": "indicates the time at which the metrics were produced", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + }, + "value": { + "description": "the value of the metric for this", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ] + }, + "window": { + "description": "indicates the window ([Timestamp-Window, Timestamp]) from which these metrics were calculated, when returning rate metrics calculated from cumulative metrics (or zero for non-calculated instantaneous metrics).", + "type": "integer", + "format": "int64" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "custom.metrics.k8s.io", + "kind": "MetricValue", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValueList": { + "description": "MetricValueList is a list of values for a given metric for some set of objects", + "type": "object", + "required": [ + "items" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "the value of the metric across the described objects", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.custom_metrics.v1beta1.MetricValue" + } + ] + } + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ] + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "custom.metrics.k8s.io", + "kind": "MetricValueList", + "version": "v1beta1" + } + ] + } + } + } +} diff --git a/gen/openapi_v1/specs/SPECS_CAPTURED b/gen/openapi_v1/specs/SPECS_CAPTURED new file mode 100644 index 00000000..28c82fbf --- /dev/null +++ b/gen/openapi_v1/specs/SPECS_CAPTURED @@ -0,0 +1,14 @@ +# Provenance for documents captured from a live cluster: aggregated APIs +# (metrics.k8s.io and the like) and CRD-backed groups, which release-tag specs +# do not carry. Kept apart from SPECS_ORIGIN because a captured document is only +# as reproducible as the cluster it came from. +# +# One record per file. Re-capturing a file replaces its record and leaves the +# others alone. + +file: apis_metrics.k8s.io_v1beta1.json +path: /openapi/v3/apis/metrics.k8s.io/v1beta1 +server: v1.35.4+k3s1 +context: default +captured: 2026-08-14T06:56:13Z +sha256: db2e242348df6877618a2c03f1b3e6f0489dcdcafb523f07ceb9e0452920cbc6 diff --git a/gen/openapi_v1/specs/SPECS_ORIGIN b/gen/openapi_v1/specs/SPECS_ORIGIN new file mode 100644 index 00000000..e88db97c --- /dev/null +++ b/gen/openapi_v1/specs/SPECS_ORIGIN @@ -0,0 +1,21 @@ +source: https://github.com/kubernetes/kubernetes tag v1.35.4 +path: api/openapi-spec/v3/ +fetched: 2026-08-13T10:40:29Z +files: +f6eb40887f8ce499c83f6032da1b35f980ecf8e6a312c06078f1356e3aa3d3e4 apis_apiextensions.k8s.io_v1.json +ac954399fa80c6e87f95858b50f5602f899e1307d37be47f38f1959783315daa apis_apiregistration.k8s.io_v1.json +8f22326dfd8be012bc6247e44bb6adb8070079c0ca9c0a527840811bccf3482e apis_apps_v1.json +baeafa1354c0f31e75e73706ebc7bafacc9e6ab3f11769dd3534199ce3e93192 apis_autoscaling_v1.json +7ac4c0478934ff422bc9060266a390f718f03198dde8cd2ba340a429a3a950cd apis_autoscaling_v2.json +75375a3f73cf46fc9351dcf21fd57192acbebb2bae96170b0831af75e860efc4 apis_batch_v1.json +c34ff08d8e1aeabdc7009943b7236491dc17d0e1c87d2754d821efdc8a8662ab apis_certificates.k8s.io_v1.json +89ceffa4453bdd1d31edfa162d63b74a8eeca6dfea5e1d787e0de2391f9cabef apis_coordination.k8s.io_v1.json +588d45f7bae86c0f2a54775d9e8af3f4b08a1d8d4e235df30bae06adc7ce90f1 apis_discovery.k8s.io_v1.json +fa533d66d3249840f74ef96ce0607073663eef5025395707a2edc3820bb5c4b6 apis_events.k8s.io_v1.json +6b974984cb19f1ef1832fdfa84b67ce600eff1db354cdb49db0edb1cf87e234f apis_networking.k8s.io_v1.json +2193906b2991a786ebb7c2edabd50d0e0a590ecce0e8c3b7c17856ae7f290533 apis_node.k8s.io_v1.json +166c6c720025c3b5a03e4cd4698a9dd876de383df07a9c0955cff8da833d51d5 apis_policy_v1.json +b65de9550d92bca038a9f72d3dadea088d268c39aec999c1a215314331af9f6d apis_rbac.authorization.k8s.io_v1.json +7bce1e2f85c8eb40ba1a821f63726ac9207361182bfaec7239591680e5487d82 apis_scheduling.k8s.io_v1.json +f5e5ae4c399889482b5228d7264b0d3bbdd0a12cb2358f26eaceffee610d9499 apis_storage.k8s.io_v1.json +45666551cf0928e4e8a9b88508f9b23aa78d2341aa27b0587457b2694717fcc1 api_v1.json diff --git a/gen/openapi_v1/specs/api_v1.json b/gen/openapi_v1/specs/api_v1.json new file mode 100644 index 00000000..8125c8ce --- /dev/null +++ b/gen/openapi_v1/specs/api_v1.json @@ -0,0 +1,39326 @@ +{ + "components": { + "schemas": { + "io.k8s.api.authentication.v1.BoundObjectReference": { + "description": "BoundObjectReference is a reference to an object that a token is bound to.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. Valid kinds are 'Pod' and 'Secret'.", + "type": "string" + }, + "name": { + "description": "Name of the referent.", + "type": "string" + }, + "uid": { + "description": "UID of the referent.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.authentication.v1.TokenRequest": { + "description": "TokenRequest requests a token for a given service account.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec" + } + ], + "default": {}, + "description": "Spec holds information about the request being evaluated" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus" + } + ], + "default": {}, + "description": "Status is filled in by the server and indicates whether the token can be authenticated." + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "authentication.k8s.io", + "kind": "TokenRequest", + "version": "v1" + } + ] + }, + "io.k8s.api.authentication.v1.TokenRequestSpec": { + "description": "TokenRequestSpec contains client provided parameters of a token request.", + "properties": { + "audiences": { + "description": "Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "boundObjectRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference" + } + ], + "description": "BoundObjectRef is a reference to an object that the token will be bound to. The token will only be valid for as long as the bound object exists. NOTE: The API server's TokenReview endpoint will validate the BoundObjectRef, but other audiences may not. Keep ExpirationSeconds small if you want prompt revocation." + }, + "expirationSeconds": { + "description": "ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "audiences" + ], + "type": "object" + }, + "io.k8s.api.authentication.v1.TokenRequestStatus": { + "description": "TokenRequestStatus is the result of a token request.", + "properties": { + "expirationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "ExpirationTimestamp is the time of expiration of the returned token." + }, + "token": { + "default": "", + "description": "Token is the opaque bearer token.", + "type": "string" + } + }, + "required": [ + "token", + "expirationTimestamp" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v1.Scale": { + "description": "Scale represents a scaling request for a resource.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec" + } + ], + "default": {}, + "description": "spec defines the behavior of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus" + } + ], + "default": {}, + "description": "status is the current status of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. Read-only." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.ScaleSpec": { + "description": "ScaleSpec describes the attributes of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the desired number of instances for the scaled object.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.ScaleStatus": { + "description": "ScaleStatus represents the current status of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the actual number of observed instances of the scaled object.", + "format": "int32", + "type": "integer" + }, + "selector": { + "description": "selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/", + "type": "string" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + } + ], + "description": "Describes node affinity scheduling rules for the pod." + }, + "podAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + } + ], + "description": "Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s))." + }, + "podAntiAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + ], + "description": "Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s))." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AttachedVolume": { + "description": "AttachedVolume describes a volume attached to a node", + "properties": { + "devicePath": { + "default": "", + "description": "DevicePath represents the device path where the volume should be available", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the attached volume", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFilePersistentVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "secretNamespace": { + "description": "secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure Share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Binding": { + "description": "Binding ties one object to another; for example, a pod is bound to a node by a scheduler.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "default": {}, + "description": "The target object that you want to bind to the standard object." + } + }, + "required": [ + "target" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Binding", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.CSIPersistentVolumeSource": { + "description": "Represents storage that is managed by an external CSI volume driver", + "properties": { + "controllerExpandSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "controllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "controllerPublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "controllerPublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerPublishVolume and ControllerUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume. Required.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\".", + "type": "string" + }, + "nodeExpandSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodeExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeExpandVolume call. This field is optional, may be omitted if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "nodePublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "nodeStageSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodeStageSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeStageVolume and NodeStageVolume and NodeUnstageVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "readOnly": { + "description": "readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes of the volume to publish.", + "type": "object" + }, + "volumeHandle": { + "default": "", + "description": "volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.", + "type": "string" + } + }, + "required": [ + "driver", + "volumeHandle" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed." + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSPersistentVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it" + }, + "user": { + "description": "user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderPersistentVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: points to a secret object containing parameters used to connect to OpenStack." + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is optional: points to a secret object containing parameters used to connect to OpenStack." + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClientIPConfig": { + "description": "ClientIPConfig represents the configurations of Client IP based session affinity.", + "properties": { + "timeoutSeconds": { + "description": "timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \"ClientIP\". Default value is 10800(for 3 hours).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Select all ClusterTrustBundles that match this label selector. Only has effect if signerName is set. Mutually-exclusive with name. If unset, interpreted as \"match nothing\". If set but empty, interpreted as \"match everything\"." + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ComponentCondition": { + "description": "Information about the condition of a component.", + "properties": { + "error": { + "description": "Condition error code for a component. For example, a health check error code.", + "type": "string" + }, + "message": { + "description": "Message about the condition for a component. For example, information about a health check.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition for a component. Valid values for \"Healthy\": \"True\", \"False\", or \"Unknown\".", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of condition for a component. Valid value: \"Healthy\"", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ComponentStatus": { + "description": "ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "conditions": { + "description": "List of component conditions observed", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ComponentStatusList": { + "description": "Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ComponentStatus objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ComponentStatusList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMap": { + "description": "ConfigMap holds configuration data for pods to consume.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "binaryData": { + "additionalProperties": { + "format": "byte", + "type": "string" + }, + "description": "BinaryData contains the binary data. Each key must consist of alphanumeric characters, '-', '_' or '.'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet.", + "type": "object" + }, + "data": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Data contains the configuration data. Each key must consist of alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process.", + "type": "object" + }, + "immutable": { + "description": "Immutable, if set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapList": { + "description": "ConfigMapList is a resource containing a list of ConfigMap objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of ConfigMaps.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ConfigMapList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMapNodeConfigSource": { + "description": "ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration", + "properties": { + "kubeletConfigKey": { + "default": "", + "description": "KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the metadata.name of the referenced ConfigMap. This field is required in all cases.", + "type": "string" + }, + "namespace": { + "default": "", + "description": "Namespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases.", + "type": "string" + }, + "resourceVersion": { + "description": "ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.", + "type": "string" + }, + "uid": { + "description": "UID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.", + "type": "string" + } + }, + "required": [ + "namespace", + "name", + "kubeletConfigKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Actions that the management system should take in response to container lifecycle events. Cannot be updated." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/" + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerExtendedResourceRequest": { + "description": "ContainerExtendedResourceRequest has the mapping of container name, extended resource name to the device request name.", + "properties": { + "containerName": { + "default": "", + "description": "The name of the container requesting resources.", + "type": "string" + }, + "requestName": { + "default": "", + "description": "The name of the request in the special ResourceClaim which corresponds to the extended resource.", + "type": "string" + }, + "resourceName": { + "default": "", + "description": "The name of the extended resource in that container which gets backed by DRA.", + "type": "string" + } + }, + "required": [ + "containerName", + "resourceName", + "requestName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerImage": { + "description": "Describe a container image", + "properties": { + "names": { + "description": "Names by which this image is known. e.g. [\"kubernetes.example/hyperkube:v1.0.7\", \"cloud-vendor.registry.example/cloud-vendor/hyperkube:v1.0.7\"]", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "sizeBytes": { + "description": "The size of the image in bytes.", + "format": "int64", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerState": { + "description": "ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.", + "properties": { + "running": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateRunning" + } + ], + "description": "Details about a running container" + }, + "terminated": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated" + } + ], + "description": "Details about a terminated container" + }, + "waiting": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting" + } + ], + "description": "Details about a waiting container" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateRunning": { + "description": "ContainerStateRunning is a running state of a container.", + "properties": { + "startedAt": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time at which the container was last (re-)started" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateTerminated": { + "description": "ContainerStateTerminated is a terminated state of a container.", + "properties": { + "containerID": { + "description": "Container's ID in the format '://'", + "type": "string" + }, + "exitCode": { + "default": 0, + "description": "Exit status from the last termination of the container", + "format": "int32", + "type": "integer" + }, + "finishedAt": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time at which the container last terminated" + }, + "message": { + "description": "Message regarding the last termination of the container", + "type": "string" + }, + "reason": { + "description": "(brief) reason from the last termination of the container", + "type": "string" + }, + "signal": { + "description": "Signal from the last termination of the container", + "format": "int32", + "type": "integer" + }, + "startedAt": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time at which previous execution of the container started" + } + }, + "required": [ + "exitCode" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateWaiting": { + "description": "ContainerStateWaiting is a waiting state of a container.", + "properties": { + "message": { + "description": "Message regarding why the container is not yet running.", + "type": "string" + }, + "reason": { + "description": "(brief) reason the container is not yet running.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStatus": { + "description": "ContainerStatus contains details for the current status of this container.", + "properties": { + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "AllocatedResources represents the compute resources allocated for this container by the node. Kubelet sets this value to Container.Resources.Requests upon successful pod admission and after successfully admitting desired pod resize.", + "type": "object" + }, + "allocatedResourcesStatus": { + "description": "AllocatedResourcesStatus represents the status of various resources allocated for this Pod.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "containerID": { + "description": "ContainerID is the ID of the container in the format '://'. Where type is a container runtime identifier, returned from Version call of CRI API (for example \"containerd\").", + "type": "string" + }, + "image": { + "default": "", + "description": "Image is the name of container image that the container is running. The container image may not match the image used in the PodSpec, as it may have been resolved by the runtime. More info: https://kubernetes.io/docs/concepts/containers/images.", + "type": "string" + }, + "imageID": { + "default": "", + "description": "ImageID is the image ID of the container's image. The image ID may not match the image ID of the image used in the PodSpec, as it may have been resolved by the runtime.", + "type": "string" + }, + "lastState": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerState" + } + ], + "default": {}, + "description": "LastTerminationState holds the last termination state of the container to help debug container crashes and restarts. This field is not populated if the container is still running and RestartCount is 0." + }, + "name": { + "default": "", + "description": "Name is a DNS_LABEL representing the unique name of the container. Each container in a pod must have a unique name across all container types. Cannot be updated.", + "type": "string" + }, + "ready": { + "default": false, + "description": "Ready specifies whether the container is currently passing its readiness check. The value will change as readiness probes keep executing. If no readiness probes are specified, this field defaults to true once the container is fully started (see Started field).\n\nThe value is typically used to determine whether a container is ready to accept traffic.", + "type": "boolean" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "description": "Resources represents the compute resource requests and limits that have been successfully enacted on the running container after it has been started or has been successfully resized." + }, + "restartCount": { + "default": 0, + "description": "RestartCount holds the number of times the container has been restarted. Kubelet makes an effort to always increment the value, but there are cases when the state may be lost due to node restarts and then the value may be reset to 0. The value is never negative.", + "format": "int32", + "type": "integer" + }, + "started": { + "description": "Started indicates whether the container has finished its postStart lifecycle hook and passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. In both cases, startup probes will run again. Is always true when no startupProbe is defined and container is running and has passed the postStart lifecycle hook. The null value must be treated the same as false.", + "type": "boolean" + }, + "state": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerState" + } + ], + "default": {}, + "description": "State holds details about the container's current condition." + }, + "stopSignal": { + "description": "StopSignal reports the effective stop signal for this container", + "type": "string" + }, + "user": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerUser" + } + ], + "description": "User represents user identity information initially attached to the first process of the container" + }, + "volumeMounts": { + "description": "Status of volume mounts.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMountStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + } + }, + "required": [ + "name", + "ready", + "restartCount", + "image", + "imageID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerUser": { + "description": "ContainerUser represents user identity information", + "properties": { + "linux": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LinuxContainerUser" + } + ], + "description": "Linux holds user identity information initially attached to the first process of the containers in Linux. Note that the actual running identity can be changed if the process has enough privilege to do so." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DaemonEndpoint": { + "description": "DaemonEndpoint contains information about a single Daemon endpoint.", + "properties": { + "Port": { + "default": 0, + "description": "Port number of the given endpoint.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "Port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported." + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported." + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EndpointAddress": { + "description": "EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "hostname": { + "description": "The Hostname of this endpoint", + "type": "string" + }, + "ip": { + "default": "", + "description": "The IP of this endpoint. May not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10), or link-local multicast (224.0.0.0/24 or ff02::/16).", + "type": "string" + }, + "nodeName": { + "description": "Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.", + "type": "string" + }, + "targetRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "Reference to object providing the endpoint." + } + }, + "required": [ + "ip" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.EndpointPort": { + "description": "EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "The name of this port. This must match the 'name' field in the corresponding ServicePort. Must be a DNS_LABEL. Optional only if one port is defined.", + "type": "string" + }, + "port": { + "default": 0, + "description": "The port number of the endpoint.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "description": "The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.EndpointSubset": { + "description": "EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given:\n\n\t{\n\t Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}]\n\t}\n\nThe resulting set of endpoints can be viewed as:\n\n\ta: [ 10.10.1.1:8675, 10.10.2.2:8675 ],\n\tb: [ 10.10.1.1:309, 10.10.2.2:309 ]\n\nDeprecated: This API is deprecated in v1.33+.", + "properties": { + "addresses": { + "description": "IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointAddress" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "notReadyAddresses": { + "description": "IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointAddress" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ports": { + "description": "Port numbers available on the related IP addresses.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Endpoints": { + "description": "Endpoints is a collection of endpoints that implement the actual service. Example:\n\n\t Name: \"mysvc\",\n\t Subsets: [\n\t {\n\t Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}]\n\t },\n\t {\n\t Addresses: [{\"ip\": \"10.10.3.3\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 93}, {\"name\": \"b\", \"port\": 76}]\n\t },\n\t]\n\nEndpoints is a legacy API and does not contain information about all Service features. Use discoveryv1.EndpointSlice for complete information about Service endpoints.\n\nDeprecated: This API is deprecated in v1.33+. Use discoveryv1.EndpointSlice.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "subsets": { + "description": "The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointSubset" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EndpointsList": { + "description": "EndpointsList is a list of endpoints. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of endpoints.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "EndpointsList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + } + ], + "description": "The ConfigMap to select from" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + ], + "description": "The Secret to select from" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + ], + "description": "Source for the environment variable's value. Cannot be used if value is not empty." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + } + ], + "description": "Selects a key of a ConfigMap." + }, + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs." + }, + "fileKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + } + ], + "description": "FileKeyRef selects a key of the env file. Requires the EnvFiles feature gate to be enabled." + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported." + }, + "secretKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + ], + "description": "Selects a key of a secret in the pod's namespace" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Lifecycle is not allowed for ephemeral containers." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext." + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + ], + "description": "Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Event": { + "description": "Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.", + "properties": { + "action": { + "description": "What action was taken/failed regarding to the Regarding object.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "count": { + "description": "The number of times this event has occurred.", + "format": "int32", + "type": "integer" + }, + "eventTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "Time when this Event was first observed." + }, + "firstTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "The time at which the event was first recorded. (Time of server receipt is in TypeMeta.)" + }, + "involvedObject": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "default": {}, + "description": "The object that this event is about." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "lastTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "The time at which the most recent occurrence of this event was recorded." + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "reason": { + "description": "This should be a short, machine understandable string that gives the reason for the transition into the object's current status.", + "type": "string" + }, + "related": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "Optional secondary object for more complex actions." + }, + "reportingComponent": { + "default": "", + "description": "Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.", + "type": "string" + }, + "reportingInstance": { + "default": "", + "description": "ID of the controller instance, e.g. `kubelet-xyzf`.", + "type": "string" + }, + "series": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSeries" + } + ], + "description": "Data about the Event series this event represents or nil if it's a singleton Event." + }, + "source": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSource" + } + ], + "default": {}, + "description": "The component reporting this event. Should be a short machine understandable string." + }, + "type": { + "description": "Type of this event (Normal, Warning), new types could be added in the future", + "type": "string" + } + }, + "required": [ + "metadata", + "involvedObject" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Event", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EventList": { + "description": "EventList is a list of events.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of events", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "EventList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EventSeries": { + "description": "EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.", + "properties": { + "count": { + "description": "Number of occurrences in this series up to the last heartbeat time", + "format": "int32", + "type": "integer" + }, + "lastObservedTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "Time of the last occurrence observed" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EventSource": { + "description": "EventSource contains information for an event.", + "properties": { + "component": { + "description": "Component from which the event is generated.", + "type": "string" + }, + "host": { + "description": "Node name on which the event is generated.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexPersistentVolumeSource": { + "description": "FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts." + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts." + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsPersistentVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "endpointsNamespace": { + "description": "endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostIP": { + "description": "HostIP represents a single IP address allocated to the host.", + "properties": { + "ip": { + "default": "", + "description": "IP is the IP address assigned to the host", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIPersistentVolumeSource": { + "description": "ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is Target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun is iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is the CHAP Secret for iSCSI target and initiator authentication" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is the CHAP Secret for iSCSI target and initiator authentication" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "preStop": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "sleep": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + } + ], + "description": "Sleep represents a duration that the container should sleep." + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for backward compatibility. There is no validation of this field and lifecycle hooks will fail at runtime when it is specified." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LimitRange": { + "description": "LimitRange sets resource usage limits for each kind of resource in a Namespace.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeSpec" + } + ], + "default": {}, + "description": "Spec defines the limits enforced. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.LimitRangeItem": { + "description": "LimitRangeItem defines a min/max usage limit for any resource that matches on kind.", + "properties": { + "default": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Default resource requirement limit value by resource name if resource limit is omitted.", + "type": "object" + }, + "defaultRequest": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "DefaultRequest is the default resource requirement request value by resource name if resource request is omitted.", + "type": "object" + }, + "max": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Max usage constraints on this kind by resource name.", + "type": "object" + }, + "maxLimitRequestRatio": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.", + "type": "object" + }, + "min": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Min usage constraints on this kind by resource name.", + "type": "object" + }, + "type": { + "default": "", + "description": "Type of resource that this limit applies to.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LimitRangeList": { + "description": "LimitRangeList is a list of LimitRange items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "LimitRangeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.LimitRangeSpec": { + "description": "LimitRangeSpec defines a min/max usage limit for resources that match on kind.", + "properties": { + "limits": { + "description": "Limits is the list of LimitRangeItem objects that are enforced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeItem" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "limits" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LinuxContainerUser": { + "description": "LinuxContainerUser represents user identity information in Linux containers", + "properties": { + "gid": { + "default": 0, + "description": "GID is the primary gid initially attached to the first process in the container", + "format": "int64", + "type": "integer" + }, + "supplementalGroups": { + "description": "SupplementalGroups are the supplemental groups initially attached to the first process in the container", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "uid": { + "default": 0, + "description": "UID is the primary uid initially attached to the first process in the container", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "uid", + "gid" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LoadBalancerIngress": { + "description": "LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point.", + "properties": { + "hostname": { + "description": "Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers)", + "type": "string" + }, + "ip": { + "description": "IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers)", + "type": "string" + }, + "ipMode": { + "description": "IPMode specifies how the load-balancer IP behaves, and may only be specified when the ip field is specified. Setting this to \"VIP\" indicates that traffic is delivered to the node with the destination set to the load-balancer's IP and port. Setting this to \"Proxy\" indicates that traffic is delivered to the node or pod with the destination set to the node's IP and node port or the pod's IP and port. Service implementations may use this information to adjust traffic routing.", + "type": "string" + }, + "ports": { + "description": "Ports is a list of records of service ports If used, every port defined in the service should have an entry in it", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LoadBalancerStatus": { + "description": "LoadBalancerStatus represents the status of a load-balancer.", + "properties": { + "ingress": { + "description": "Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.LocalVolumeSource": { + "description": "Local represents directly-attached storage with node affinity", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a filesystem if unspecified.", + "type": "string" + }, + "path": { + "default": "", + "description": "path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ModifyVolumeStatus": { + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation", + "properties": { + "status": { + "default": "", + "description": "status is the status of the ControllerModifyVolume operation. It can be in any of following states:\n - Pending\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\n the specified VolumeAttributesClass not existing.\n - InProgress\n InProgress indicates that the volume is being modified.\n - Infeasible\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\n\t resolve the error, a valid VolumeAttributesClass needs to be specified.\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.", + "type": "string" + }, + "targetVolumeAttributesClassName": { + "description": "targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled", + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Namespace": { + "description": "Namespace provides a scope for Names. Use of multiple namespaces is optional.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceSpec" + } + ], + "default": {}, + "description": "Spec defines the behavior of the Namespace. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceStatus" + } + ], + "default": {}, + "description": "Status describes the current status of a Namespace. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Namespace", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NamespaceCondition": { + "description": "NamespaceCondition contains details about state of namespace.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of namespace controller condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NamespaceList": { + "description": "NamespaceList is a list of Namespaces.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "NamespaceList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NamespaceSpec": { + "description": "NamespaceSpec describes the attributes on a Namespace.", + "properties": { + "finalizers": { + "description": "Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NamespaceStatus": { + "description": "NamespaceStatus is information about the current status of a Namespace.", + "properties": { + "conditions": { + "description": "Represents the latest available observations of a namespace's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "phase": { + "description": "Phase is the current lifecycle phase of the namespace. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Node": { + "description": "Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd).", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSpec" + } + ], + "default": {}, + "description": "Spec defines the behavior of a node. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeStatus" + } + ], + "default": {}, + "description": "Most recently observed status of the node. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Node", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NodeAddress": { + "description": "NodeAddress contains information for the node's address.", + "properties": { + "address": { + "default": "", + "description": "The node address.", + "type": "string" + }, + "type": { + "default": "", + "description": "Node address type, one of Hostname, ExternalIP or InternalIP.", + "type": "string" + } + }, + "required": [ + "type", + "address" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + ], + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeCondition": { + "description": "NodeCondition contains condition information for a node.", + "properties": { + "lastHeartbeatTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time we got an update on a given condition." + }, + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transit from one status to another." + }, + "message": { + "description": "Human readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "(brief) reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of node condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeConfigSource": { + "description": "NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. This API is deprecated since 1.22", + "properties": { + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource" + } + ], + "description": "ConfigMap is a reference to a Node's ConfigMap" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeConfigStatus": { + "description": "NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource.", + "properties": { + "active": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + } + ], + "description": "Active reports the checkpointed config the node is actively using. Active will represent either the current version of the Assigned config, or the current LastKnownGood config, depending on whether attempting to use the Assigned config results in an error." + }, + "assigned": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + } + ], + "description": "Assigned reports the checkpointed config the node will try to use. When Node.Spec.ConfigSource is updated, the node checkpoints the associated config payload to local disk, along with a record indicating intended config. The node refers to this record to choose its config checkpoint, and reports this record in Assigned. Assigned only updates in the status after the record has been checkpointed to disk. When the Kubelet is restarted, it tries to make the Assigned config the Active config by loading and validating the checkpointed payload identified by Assigned." + }, + "error": { + "description": "Error describes any problems reconciling the Spec.ConfigSource to the Active config. Errors may occur, for example, attempting to checkpoint Spec.ConfigSource to the local Assigned record, attempting to checkpoint the payload associated with Spec.ConfigSource, attempting to load or validate the Assigned config, etc. Errors may occur at different points while syncing config. Earlier errors (e.g. download or checkpointing errors) will not result in a rollback to LastKnownGood, and may resolve across Kubelet retries. Later errors (e.g. loading or validating a checkpointed config) will result in a rollback to LastKnownGood. In the latter case, it is usually possible to resolve the error by fixing the config assigned in Spec.ConfigSource. You can find additional information for debugging by searching the error message in the Kubelet log. Error is a human-readable description of the error state; machines can check whether or not Error is empty, but should not rely on the stability of the Error text across Kubelet versions.", + "type": "string" + }, + "lastKnownGood": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + } + ], + "description": "LastKnownGood reports the checkpointed config the node will fall back to when it encounters an error attempting to use the Assigned config. The Assigned config becomes the LastKnownGood config when the node determines that the Assigned config is stable and correct. This is currently implemented as a 10-minute soak period starting when the local record of Assigned config is updated. If the Assigned config is Active at the end of this period, it becomes the LastKnownGood. Note that if Spec.ConfigSource is reset to nil (use local defaults), the LastKnownGood is also immediately reset to nil, because the local default config is always assumed good. You should not make assumptions about the node's method of determining config stability and correctness, as this may change or become configurable in the future." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeDaemonEndpoints": { + "description": "NodeDaemonEndpoints lists ports opened by daemons running on the Node.", + "properties": { + "kubeletEndpoint": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DaemonEndpoint" + } + ], + "default": {}, + "description": "Endpoint on which Kubelet is listening." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeFeatures": { + "description": "NodeFeatures describes the set of features implemented by the CRI implementation. The features contained in the NodeFeatures should depend only on the cri implementation independent of runtime handlers.", + "properties": { + "supplementalGroupsPolicy": { + "description": "SupplementalGroupsPolicy is set to true if the runtime supports SupplementalGroupsPolicy and ContainerUser.", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeList": { + "description": "NodeList is the whole list of all Nodes which have been registered with master.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of nodes", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "NodeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NodeRuntimeHandler": { + "description": "NodeRuntimeHandler is a set of runtime handler information.", + "properties": { + "features": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures" + } + ], + "description": "Supported features." + }, + "name": { + "default": "", + "description": "Runtime handler name. Empty for the default runtime handler.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeRuntimeHandlerFeatures": { + "description": "NodeRuntimeHandlerFeatures is a set of features implemented by the runtime handler.", + "properties": { + "recursiveReadOnlyMounts": { + "description": "RecursiveReadOnlyMounts is set to true if the runtime handler supports RecursiveReadOnlyMounts.", + "type": "boolean" + }, + "userNamespaces": { + "description": "UserNamespaces is set to true if the runtime handler supports UserNamespaces, including for volumes.", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSpec": { + "description": "NodeSpec describes the attributes that a node is created with.", + "properties": { + "configSource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + } + ], + "description": "Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed." + }, + "externalID": { + "description": "Deprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966", + "type": "string" + }, + "podCIDR": { + "description": "PodCIDR represents the pod IP range assigned to the node.", + "type": "string" + }, + "podCIDRs": { + "description": "podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "providerID": { + "description": "ID of the node assigned by the cloud provider in the format: ://", + "type": "string" + }, + "taints": { + "description": "If specified, the node's taints.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Taint" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "unschedulable": { + "description": "Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeStatus": { + "description": "NodeStatus is information about the current status of a node.", + "properties": { + "addresses": { + "description": "List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/reference/node/node-status/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. Consumers should assume that addresses can change during the lifetime of a Node. However, there are some exceptions where this may not be possible, such as Pods that inherit a Node's address in its own status or consumers of the downward API (status.hostIP).", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAddress" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "allocatable": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/reference/node/node-status/#capacity", + "type": "object" + }, + "conditions": { + "description": "Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/reference/node/node-status/#condition", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "config": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigStatus" + } + ], + "description": "Status of the config assigned to the node via the dynamic Kubelet config feature." + }, + "daemonEndpoints": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints" + } + ], + "default": {}, + "description": "Endpoints of daemons running on the Node." + }, + "declaredFeatures": { + "description": "DeclaredFeatures represents the features related to feature gates that are declared by the node.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "features": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeFeatures" + } + ], + "description": "Features describes the set of features implemented by the CRI implementation." + }, + "images": { + "description": "List of container images on this node", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerImage" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "nodeInfo": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSystemInfo" + } + ], + "default": {}, + "description": "Set of ids/uuids to uniquely identify the node. More info: https://kubernetes.io/docs/reference/node/node-status/#info" + }, + "phase": { + "description": "NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated.", + "type": "string" + }, + "runtimeHandlers": { + "description": "The available runtime handlers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "volumesAttached": { + "description": "List of volumes that are attached to the node.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AttachedVolume" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "volumesInUse": { + "description": "List of attachable volumes in use (mounted) by the node.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSwapStatus": { + "description": "NodeSwapStatus represents swap memory information.", + "properties": { + "capacity": { + "description": "Total amount of swap memory in bytes.", + "format": "int64", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSystemInfo": { + "description": "NodeSystemInfo is a set of ids/uuids to uniquely identify the node.", + "properties": { + "architecture": { + "default": "", + "description": "The Architecture reported by the node", + "type": "string" + }, + "bootID": { + "default": "", + "description": "Boot ID reported by the node.", + "type": "string" + }, + "containerRuntimeVersion": { + "default": "", + "description": "ContainerRuntime Version reported by the node through runtime remote API (e.g. containerd://1.4.2).", + "type": "string" + }, + "kernelVersion": { + "default": "", + "description": "Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64).", + "type": "string" + }, + "kubeProxyVersion": { + "default": "", + "description": "Deprecated: KubeProxy Version reported by the node.", + "type": "string" + }, + "kubeletVersion": { + "default": "", + "description": "Kubelet Version reported by the node.", + "type": "string" + }, + "machineID": { + "default": "", + "description": "MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html", + "type": "string" + }, + "operatingSystem": { + "default": "", + "description": "The Operating System reported by the node", + "type": "string" + }, + "osImage": { + "default": "", + "description": "OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).", + "type": "string" + }, + "swap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSwapStatus" + } + ], + "description": "Swap Info reported by the node." + }, + "systemUUID": { + "default": "", + "description": "SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid", + "type": "string" + } + }, + "required": [ + "machineID", + "systemUUID", + "bootID", + "kernelVersion", + "osImage", + "containerRuntimeVersion", + "kubeletVersion", + "kubeProxyVersion", + "operatingSystem", + "architecture" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolume": { + "description": "PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec" + } + ], + "default": {}, + "description": "spec defines a specification of a persistent volume owned by the cluster. Provisioned by an administrator. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumes" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus" + } + ], + "default": {}, + "description": "status represents the current information/status for the persistent volume. Populated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumes" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaim": { + "description": "PersistentVolumeClaim is a user's request for and claim to a persistent volume", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + ], + "default": {}, + "description": "spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus" + } + ], + "default": {}, + "description": "status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimCondition": { + "description": "PersistentVolumeClaimCondition contains details about state of pvc", + "properties": { + "lastProbeTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastProbeTime is the time we probed the condition." + }, + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the time the condition transitioned from one status to another." + }, + "message": { + "description": "message is the human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"Resizing\" that means the underlying persistent volume is being resized.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimList": { + "description": "PersistentVolumeClaimList is a list of PersistentVolumeClaim items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaimList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "dataSource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + } + ], + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." + }, + "dataSourceRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + } + ], + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + } + ], + "default": {}, + "description": "resources represents the minimum resources the volume should have. Users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "selector is a label query over volumes to consider for binding." + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimStatus": { + "description": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "properties": { + "accessModes": { + "description": "accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "allocatedResourceStatuses": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nClaimResourceStatus can be in any of following states:\n\t- ControllerResizeInProgress:\n\t\tState set when resize controller starts resizing the volume in control-plane.\n\t- ControllerResizeFailed:\n\t\tState set when resize has failed in resize controller with a terminal error.\n\t- NodeResizePending:\n\t\tState set when resize controller has finished resizing the volume but further resizing of\n\t\tvolume is needed on the node.\n\t- NodeResizeInProgress:\n\t\tState set when kubelet starts resizing the volume.\n\t- NodeResizeFailed:\n\t\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\n\t\tNodeResizeFailed.\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\n\t- pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeFailed\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizePending\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeFailed\"\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\n\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object", + "x-kubernetes-map-type": "granular" + }, + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\n\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity represents the actual resources of the underlying volume.", + "type": "object" + }, + "conditions": { + "description": "conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentVolumeAttributesClassName": { + "description": "currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim", + "type": "string" + }, + "modifyVolumeStatus": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus" + } + ], + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation. When this is unset, there is no ModifyVolume operation being attempted." + }, + "phase": { + "description": "phase represents the current phase of PersistentVolumeClaim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + ], + "default": {}, + "description": "The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here." + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeList": { + "description": "PersistentVolumeList is a list of PersistentVolume items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeSpec": { + "description": "PersistentVolumeSpec is the specification of a persistent volume.", + "properties": { + "accessModes": { + "description": "accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "awsElasticBlockStore": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + } + ], + "description": "awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore" + }, + "azureDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + } + ], + "description": "azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver." + }, + "azureFile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource" + } + ], + "description": "azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver." + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity", + "type": "object" + }, + "cephfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource" + } + ], + "description": "cephFS represents a Ceph FS mount on the host that shares a pod's lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported." + }, + "cinder": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource" + } + ], + "description": "cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: https://examples.k8s.io/mysql-cinder-pd/README.md" + }, + "claimRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "claimRef is part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim. Expected to be non-nil when bound. claim.VolumeName is the authoritative bind between PV and PVC. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding", + "x-kubernetes-map-type": "granular" + }, + "csi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource" + } + ], + "description": "csi represents storage that is handled by an external CSI driver." + }, + "fc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + } + ], + "description": "fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod." + }, + "flexVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource" + } + ], + "description": "flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead." + }, + "flocker": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + } + ], + "description": "flocker represents a Flocker volume attached to a kubelet's host machine and exposed to the pod for its usage. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported." + }, + "gcePersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + } + ], + "description": "gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk" + }, + "glusterfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource" + } + ], + "description": "glusterfs represents a Glusterfs volume that is attached to a host and exposed to the pod. Provisioned by an admin. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported. More info: https://examples.k8s.io/volumes/glusterfs/README.md" + }, + "hostPath": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + } + ], + "description": "hostPath represents a directory on the host. Provisioned by a developer or tester. This is useful for single-node development and testing only! On-host storage is not supported in any way and WILL NOT WORK in a multi-node cluster. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath" + }, + "iscsi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource" + } + ], + "description": "iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin." + }, + "local": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource" + } + ], + "description": "local represents directly-attached storage with node affinity" + }, + "mountOptions": { + "description": "mountOptions is the list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "nfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + } + ], + "description": "nfs represents an NFS mount on the host. Provisioned by an admin. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs" + }, + "nodeAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity" + } + ], + "description": "nodeAffinity defines constraints that limit what nodes this volume can be accessed from. This field influences the scheduling of pods that use this volume. This field is mutable if MutablePVNodeAffinity feature gate is enabled." + }, + "persistentVolumeReclaimPolicy": { + "description": "persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming", + "type": "string" + }, + "photonPersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + } + ], + "description": "photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported." + }, + "portworxVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + } + ], + "description": "portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver when the CSIMigrationPortworx feature-gate is on." + }, + "quobyte": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + } + ], + "description": "quobyte represents a Quobyte mount on the host that shares a pod's lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported." + }, + "rbd": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource" + } + ], + "description": "rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported. More info: https://examples.k8s.io/volumes/rbd/README.md" + }, + "scaleIO": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource" + } + ], + "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported." + }, + "storageClassName": { + "description": "storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.", + "type": "string" + }, + "storageos": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource" + } + ], + "description": "storageOS represents a StorageOS volume that is attached to the kubelet's host machine and mounted into the pod. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported. More info: https://examples.k8s.io/volumes/storageos/README.md" + }, + "volumeAttributesClassName": { + "description": "Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.", + "type": "string" + }, + "vsphereVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + ], + "description": "vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeStatus": { + "description": "PersistentVolumeStatus is the current status of a persistent volume.", + "properties": { + "lastPhaseTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastPhaseTransitionTime is the time the phase transitioned from one to another and automatically resets to current time everytime a volume phase transitions." + }, + "message": { + "description": "message is a human-readable message indicating details about why the volume is in this state.", + "type": "string" + }, + "phase": { + "description": "phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase", + "type": "string" + }, + "reason": { + "description": "reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Pod": { + "description": "Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodStatus" + } + ], + "default": {}, + "description": "Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Pod", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "namespaceSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces." + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodCondition": { + "description": "PodCondition contains details for the current condition of this pod.", + "properties": { + "lastProbeTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time we probed the condition." + }, + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "observedGeneration": { + "description": "If set, this represents the .metadata.generation that the pod condition was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.", + "format": "int64", + "type": "integer" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodExtendedResourceClaimStatus": { + "description": "PodExtendedResourceClaimStatus is stored in the PodStatus for the extended resource requests backed by DRA. It stores the generated name for the corresponding special ResourceClaim created by the scheduler.", + "properties": { + "requestMappings": { + "description": "RequestMappings identifies the mapping of to device request in the generated ResourceClaim.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resourceClaimName": { + "default": "", + "description": "ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod.", + "type": "string" + } + }, + "required": [ + "requestMappings", + "resourceClaimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodIP": { + "description": "PodIP represents a single IP address allocated to the pod.", + "properties": { + "ip": { + "default": "", + "description": "IP is the IP address assigned to the pod", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodList": { + "description": "PodList is a list of Pods.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pods. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaimStatus": { + "description": "PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must match the name of an entry in pod.spec.resourceClaims, which implies that the string must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod. If this is unset, then generating a ResourceClaim was not necessary. The pod.spec.resourceClaims entry can be ignored in this case.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + } + ], + "description": "If specified, the pod's scheduling constraints" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "dnsConfig": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + } + ], + "description": "Specifies the DNS parameters of a pod. Parameters specified here will be merged to the generated DNS configuration based on DNSPolicy." + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge" + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + } + ], + "description": "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.\n\nIf the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions\n\nIf the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.hostUsers - spec.resources - spec.securityContext.appArmorProfile - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.securityContext.supplementalGroupsPolicy - spec.containers[*].securityContext.appArmorProfile - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "description": "Resources is the total amount of CPU and Memory resources required by all containers in the pod. It supports specifying Requests and Limits for \"cpu\", \"memory\" and \"hugepages-\" resource names only. ResourceClaims are not supported.\n\nThis field enables fine-grained control over resource allocation for the entire pod, allowing resource sharing among containers in a pod.\n\nThis is an alpha field and requires enabling the PodLevelResources feature gate." + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + } + ], + "description": "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field." + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge" + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "workloadRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + ], + "description": "WorkloadRef provides a reference to the Workload object that this Pod belongs to. This field is used by the scheduler to identify the PodGroup and apply the correct group scheduling policies. The Workload object referenced by this field may not exist at the time the Pod is created. This field is immutable, but a Workload object with the same name may be recreated with different policies. Doing this during pod scheduling may result in the placement not conforming to the expected policies." + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodStatus": { + "description": "PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane.", + "properties": { + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "AllocatedResources is the total requests allocated for this pod by the node. If pod-level requests are not set, this will be the total requests aggregated across containers in the pod.", + "type": "object" + }, + "conditions": { + "description": "Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "containerStatuses": { + "description": "Statuses of containers in this pod. Each container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ephemeralContainerStatuses": { + "description": "Statuses for any ephemeral containers that have run in this pod. Each ephemeral container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "extendedResourceClaimStatus": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus" + } + ], + "description": "Status of extended resource claim backed by DRA." + }, + "hostIP": { + "description": "hostIP holds the IP address of the host to which the pod is assigned. Empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns mean that HostIP will not be updated even if there is a node is assigned to pod", + "type": "string" + }, + "hostIPs": { + "description": "hostIPs holds the IP addresses allocated to the host. If this field is specified, the first entry must match the hostIP field. This list is empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns means that HostIPs will not be updated even if there is a node is assigned to this pod.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostIP" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge" + }, + "initContainerStatuses": { + "description": "Statuses of init containers in this pod. The most recent successful non-restartable init container will have ready = true, the most recently started container will have startTime set. Each init container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-and-container-status", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "message": { + "description": "A human readable message indicating details about why the pod is in this condition.", + "type": "string" + }, + "nominatedNodeName": { + "description": "nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.", + "type": "string" + }, + "observedGeneration": { + "description": "If set, this represents the .metadata.generation that the pod status was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.", + "format": "int64", + "type": "integer" + }, + "phase": { + "description": "The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:\n\nPending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod.\n\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase", + "type": "string" + }, + "podIP": { + "description": "podIP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.", + "type": "string" + }, + "podIPs": { + "description": "podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodIP" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge" + }, + "qosClass": { + "description": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/#quality-of-service-classes", + "type": "string" + }, + "reason": { + "description": "A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted'", + "type": "string" + }, + "resize": { + "description": "Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to \"Proposed\" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.", + "type": "string" + }, + "resourceClaimStatuses": { + "description": "Status of resource claims.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "description": "Resources represents the compute resource requests and limits that have been applied at the pod level if pod-level requests or limits are set in PodSpec.Resources" + }, + "startTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "RFC 3339 date and time at which the object was acknowledged by the Kubelet. This is before the Kubelet pulled the container image(s) for the pod." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplate": { + "description": "PodTemplate describes a template for creating copies of a predefined pod.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "Template defines the pods that will be created from this pod template. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodTemplateList": { + "description": "PodTemplateList is a list of PodTemplates.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pod templates", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodTemplateList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortStatus": { + "description": "PortStatus represents the error condition of a service port", + "properties": { + "error": { + "description": "Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\n CamelCase names\n- cloud provider specific error values must have names that comply with the\n format foo.example.com/CamelCase.", + "type": "string" + }, + "port": { + "default": 0, + "description": "Port is the port number of the service port of which status is recorded here", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "", + "description": "Protocol is the protocol of the service port of which status is recorded here The supported values are: \"TCP\", \"UDP\", \"SCTP\"", + "type": "string" + } + }, + "required": [ + "port", + "protocol" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {}, + "description": "A node selector term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + } + ], + "description": "GRPC specifies a GRPC HealthCheckRequest." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "TCPSocket specifies a connection to a TCP port." + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDPersistentVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationController": { + "description": "ReplicationController represents the configuration of a replication controller.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "If the Labels of a ReplicationController are empty, they are defaulted to be the same as the Pod(s) that the replication controller manages. Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec" + } + ], + "default": {}, + "description": "Spec defines the specification of the desired behavior of the replication controller. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus" + } + ], + "default": {}, + "description": "Status is the most recently observed status of the replication controller. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ReplicationControllerCondition": { + "description": "ReplicationControllerCondition describes the state of a replication controller at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "The last time the condition transitioned from one status to another." + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of replication controller condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationControllerList": { + "description": "ReplicationControllerList is a collection of replication controllers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ReplicationControllerList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ReplicationControllerSpec": { + "description": "ReplicationControllerSpec is the specification of a replication controller.", + "properties": { + "minReadySeconds": { + "default": 0, + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 1, + "description": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller", + "format": "int32", + "type": "integer" + }, + "selector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "description": "Template is the object that describes the pod that will be created if insufficient replicas are detected. This takes precedence over a TemplateRef. The only allowed template.spec.restartPolicy value is \"Always\". More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationControllerStatus": { + "description": "ReplicationControllerStatus represents the current status of a replication controller.", + "properties": { + "availableReplicas": { + "description": "The number of available replicas (ready for at least minReadySeconds) for this replication controller.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a replication controller's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "fullyLabeledReplicas": { + "description": "The number of pods that have labels matching the labels of the pod template of the replication controller.", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "ObservedGeneration reflects the generation of the most recently observed replication controller.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "The number of ready replicas for this replication controller.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "Replicas is the most recently observed number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "Specifies the output format of the exposed resources, defaults to \"1\"" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceHealth": { + "description": "ResourceHealth represents the health of a resource. It has the latest device health information. This is a part of KEP https://kep.k8s.io/4680.", + "properties": { + "health": { + "description": "Health of the resource. can be one of:\n - Healthy: operates as normal\n - Unhealthy: reported unhealthy. We consider this a temporary health issue\n since we do not have a mechanism today to distinguish\n temporary and permanent issues.\n - Unknown: The status cannot be determined.\n For example, Device Plugin got unregistered and hasn't been re-registered since.\n\nIn future we may want to introduce the PermanentlyUnhealthy Status.", + "type": "string" + }, + "resourceID": { + "default": "", + "description": "ResourceID is the unique identifier of the resource. See the ResourceID type for more information.", + "type": "string" + } + }, + "required": [ + "resourceID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceQuota": { + "description": "ResourceQuota sets aggregate quota restrictions enforced per namespace", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec" + } + ], + "default": {}, + "description": "Spec defines the desired quota. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus" + } + ], + "default": {}, + "description": "Status defines the actual enforced quota and its current usage. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ResourceQuotaList": { + "description": "ResourceQuotaList is a list of ResourceQuota items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ResourceQuotaList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ResourceQuotaSpec": { + "description": "ResourceQuotaSpec defines the desired hard limits to enforce for Quota.", + "properties": { + "hard": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "type": "object" + }, + "scopeSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScopeSelector" + } + ], + "description": "scopeSelector is also a collection of filters like scopes that must match each object tracked by a quota but expressed using ScopeSelectorOperator in combination with possible values. For a resource to match, both scopes AND scopeSelector (if specified in spec), must be matched." + }, + "scopes": { + "description": "A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceQuotaStatus": { + "description": "ResourceQuotaStatus defines the enforced hard limits and observed use.", + "properties": { + "hard": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "type": "object" + }, + "used": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Used is the current observed total usage of the resource in the namespace.", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map" + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceStatus": { + "description": "ResourceStatus represents the status of a single resource allocated to a Pod.", + "properties": { + "name": { + "default": "", + "description": "Name of the resource. Must be unique within the pod and in case of non-DRA resource, match one of the resources from the pod spec. For DRA resources, the value must be \"claim:/\". When this status is reported about a container, the \"claim_name\" and \"request\" must match one of the claims of this container.", + "type": "string" + }, + "resources": { + "description": "List of unique resources health. Each element in the list contains an unique resource ID and its health. At a minimum, for the lifetime of a Pod, resource ID must uniquely identify the resource allocated to the Pod on the Node. If other Pod on the same Node reports the status with the same resource ID, it must be the same resource they share. See ResourceID type definition for a specific format it has in various use cases.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceHealth" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "resourceID" + ], + "x-kubernetes-list-type": "map" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOPersistentVolumeSource": { + "description": "ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\"", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail." + }, + "sslEnabled": { + "description": "sslEnabled is the flag to enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail." + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScopeSelector": { + "description": "A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements.", + "properties": { + "matchExpressions": { + "description": "A list of scope selector requirements by scope of the resources.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ScopedResourceSelectorRequirement": { + "description": "A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values.", + "properties": { + "operator": { + "default": "", + "description": "Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist.", + "type": "string" + }, + "scopeName": { + "default": "", + "description": "The name of the scope that the selector applies to.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "scopeName", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.Secret": { + "description": "Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "data": { + "additionalProperties": { + "format": "byte", + "type": "string" + }, + "description": "Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4", + "type": "object" + }, + "immutable": { + "description": "Immutable, if set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "stringData": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "stringData allows specifying non-binary secret data in string form. It is provided as a write-only input field for convenience. All keys and values are merged into the data field on write, overwriting any existing values. The stringData field is never output when reading from the API.", + "type": "object" + }, + "type": { + "description": "Used to facilitate programmatic handling of secret data. More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Secret", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretList": { + "description": "SecretList is a list of Secret.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "SecretList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretReference": { + "description": "SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace", + "properties": { + "name": { + "description": "name is unique within a namespace to reference a secret resource.", + "type": "string" + }, + "namespace": { + "description": "namespace defines the space within which the secret name must be unique.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by this container. If set, this profile overrides the pod's appArmorProfile. Note that this field cannot be set when spec.os.name is windows." + }, + "capabilities": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + } + ], + "description": "The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows." + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows." + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Service": { + "description": "Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceSpec" + } + ], + "default": {}, + "description": "Spec defines the behavior of a service. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceStatus" + } + ], + "default": {}, + "description": "Most recently observed status of the service. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Service", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccount": { + "description": "ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level.", + "type": "boolean" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "secrets": { + "description": "Secrets is a list of the secrets in the same namespace that pods running using this ServiceAccount are allowed to use. Pods are only limited to this list if this service account has a \"kubernetes.io/enforce-mountable-secrets\" annotation set to \"true\". The \"kubernetes.io/enforce-mountable-secrets\" annotation is deprecated since v1.32. Prefer separate namespaces to isolate access to mounted secrets. This field should not be used to find auto-generated service account token secrets for use outside of pods. Instead, tokens can be requested directly using the TokenRequest API, or service account token secrets can be manually created. More info: https://kubernetes.io/docs/concepts/configuration/secret", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccountList": { + "description": "ServiceAccountList is a list of ServiceAccount objects", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceAccountList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ServiceList": { + "description": "ServiceList holds a list of services.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of services", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServicePort": { + "description": "ServicePort contains information on service's port.", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. When considering the endpoints for a Service, this must match the 'name' field in the EndpointPort. Optional if only one ServicePort is defined on this service.", + "type": "string" + }, + "nodePort": { + "description": "The port on each node on which this service is exposed when type is NodePort or LoadBalancer. Usually assigned by the system. If a value is specified, in-range, and not in use it will be used, otherwise the operation will fail. If not specified, a port will be allocated if this Service requires one. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type from NodePort to ClusterIP). More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport", + "format": "int32", + "type": "integer" + }, + "port": { + "default": 0, + "description": "The port that will be exposed by this service.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "TCP", + "description": "The IP protocol for this port. Supports \"TCP\", \"UDP\", and \"SCTP\". Default is TCP.", + "type": "string" + }, + "targetPort": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Number or name of the port to access on the pods targeted by the service. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. If this is a string, it will be looked up as a named port in the target Pod's container ports. If this is not specified, the value of the 'port' field is used (an identity map). This field is ignored for services with clusterIP=None, and should be omitted or set equal to the 'port' field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ServiceSpec": { + "description": "ServiceSpec describes the attributes that a user creates on a service.", + "properties": { + "allocateLoadBalancerNodePorts": { + "description": "allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is \"true\". It may be set to \"false\" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type.", + "type": "boolean" + }, + "clusterIP": { + "description": "clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "type": "string" + }, + "clusterIPs": { + "description": "ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\n\nThis field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "externalIPs": { + "description": "externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "externalName": { + "description": "externalName is the external reference that discovery mechanisms will return as an alias for this service (e.g. a DNS CNAME record). No proxying will be involved. Must be a lowercase RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires `type` to be \"ExternalName\".", + "type": "string" + }, + "externalTrafficPolicy": { + "description": "externalTrafficPolicy describes how nodes distribute service traffic they receive on one of the Service's \"externally-facing\" addresses (NodePorts, ExternalIPs, and LoadBalancer IPs). If set to \"Local\", the proxy will configure the service in a way that assumes that external load balancers will take care of balancing the service traffic between nodes, and so each node will deliver traffic only to the node-local endpoints of the service, without masquerading the client source IP. (Traffic mistakenly sent to a node with no endpoints will be dropped.) The default value, \"Cluster\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features). Note that traffic sent to an External IP or LoadBalancer IP from within the cluster will always get \"Cluster\" semantics, but clients sending to a NodePort from within the cluster may need to take traffic policy into account when picking a node.", + "type": "string" + }, + "healthCheckNodePort": { + "description": "healthCheckNodePort specifies the healthcheck nodePort for the service. This only applies when type is set to LoadBalancer and externalTrafficPolicy is set to Local. If a value is specified, is in-range, and is not in use, it will be used. If not specified, a value will be automatically allocated. External systems (e.g. load-balancers) can use this port to determine if a given node holds endpoints for this service or not. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type). This field cannot be updated once set.", + "format": "int32", + "type": "integer" + }, + "internalTrafficPolicy": { + "description": "InternalTrafficPolicy describes how nodes distribute service traffic they receive on the ClusterIP. If set to \"Local\", the proxy will assume that pods only want to talk to endpoints of the service on the same node as the pod, dropping the traffic if there are no local endpoints. The default value, \"Cluster\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features).", + "type": "string" + }, + "ipFamilies": { + "description": "IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \"IPv4\" and \"IPv6\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \"headless\" services. This field will be wiped when updating a Service to type ExternalName.\n\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ipFamilyPolicy": { + "description": "IPFamilyPolicy represents the dual-stack-ness requested or required by this Service. If there is no value provided, then this field will be set to SingleStack. Services can be \"SingleStack\" (a single IP family), \"PreferDualStack\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \"RequireDualStack\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.", + "type": "string" + }, + "loadBalancerClass": { + "description": "loadBalancerClass is the class of the load balancer implementation this Service belongs to. If specified, the value of this field must be a label-style identifier, with an optional prefix, e.g. \"internal-vip\" or \"example.com/internal-vip\". Unprefixed names are reserved for end-users. This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load balancer implementation is used, today this is typically done through the cloud provider integration, but should apply for any default implementation. If set, it is assumed that a load balancer implementation is watching for Services with a matching class. Any default load balancer implementation (e.g. cloud providers) should ignore Services that set this field. This field can only be set when creating or updating a Service to type 'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.", + "type": "string" + }, + "loadBalancerIP": { + "description": "Only applies to Service Type: LoadBalancer. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. Deprecated: This field was under-specified and its meaning varies across implementations. Using it is non-portable and it may not support dual-stack. Users are encouraged to use implementation-specific annotations when available.", + "type": "string" + }, + "loadBalancerSourceRanges": { + "description": "If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ports": { + "description": "The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServicePort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "port", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "port", + "x-kubernetes-patch-strategy": "merge" + }, + "publishNotReadyAddresses": { + "description": "publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service should disregard any indications of ready/not-ready. The primary use case for setting this field is for a StatefulSet's Headless Service to propagate SRV DNS records for its Pods for the purpose of peer discovery. The Kubernetes controllers that generate Endpoints and EndpointSlice resources for Services interpret this to mean that all endpoints are considered \"ready\" even if the Pods themselves are not. Agents which consume only Kubernetes generated endpoints through the Endpoints or EndpointSlice resources can safely assume this behavior.", + "type": "boolean" + }, + "selector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "sessionAffinity": { + "description": "Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "type": "string" + }, + "sessionAffinityConfig": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig" + } + ], + "description": "sessionAffinityConfig contains the configurations of session affinity." + }, + "trafficDistribution": { + "description": "TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to \"PreferClose\", implementations should prioritize endpoints that are in the same zone.", + "type": "string" + }, + "type": { + "description": "type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. \"ExternalName\" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceStatus": { + "description": "ServiceStatus represents the current status of a service.", + "properties": { + "conditions": { + "description": "Current service state", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "loadBalancer": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus" + } + ], + "default": {}, + "description": "LoadBalancer contains the current status of the load-balancer, if one is present." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SessionAffinityConfig": { + "description": "SessionAffinityConfig represents the configurations of session affinity.", + "properties": { + "clientIP": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClientIPConfig" + } + ], + "description": "clientIP contains the configurations of Client IP based session affinity." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSPersistentVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted." + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted." + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Taint": { + "description": "The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint.", + "properties": { + "effect": { + "default": "", + "description": "Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "default": "", + "description": "Required. The taint key to be applied to a node.", + "type": "string" + }, + "timeAdded": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "TimeAdded represents the time at which the taint was added." + }, + "value": { + "description": "The taint value corresponding to the taint key.", + "type": "string" + } + }, + "required": [ + "key", + "effect" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + } + ], + "description": "awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore" + }, + "azureDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + } + ], + "description": "azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver." + }, + "azureFile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + } + ], + "description": "azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver." + }, + "cephfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + } + ], + "description": "cephFS represents a Ceph FS mount on the host that shares a pod's lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported." + }, + "cinder": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + } + ], + "description": "cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: https://examples.k8s.io/mysql-cinder-pd/README.md" + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + } + ], + "description": "configMap represents a configMap that should populate this volume" + }, + "csi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + } + ], + "description": "csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers." + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + } + ], + "description": "downwardAPI represents downward API about the pod that should populate this volume" + }, + "emptyDir": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + } + ], + "description": "emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + }, + "ephemeral": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + } + ], + "description": "ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time." + }, + "fc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + } + ], + "description": "fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod." + }, + "flexVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + } + ], + "description": "flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead." + }, + "flocker": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + } + ], + "description": "flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported." + }, + "gcePersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + } + ], + "description": "gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk" + }, + "gitRepo": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + } + ], + "description": "gitRepo represents a git repository at a particular revision. Deprecated: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container." + }, + "glusterfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + } + ], + "description": "glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported." + }, + "hostPath": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + } + ], + "description": "hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath" + }, + "image": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + } + ], + "description": "image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet's host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided:\n\n- Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.\n\nThe volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type." + }, + "iscsi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + } + ], + "description": "iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes/#iscsi" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + } + ], + "description": "nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs" + }, + "persistentVolumeClaim": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + } + ], + "description": "persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + }, + "photonPersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + } + ], + "description": "photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported." + }, + "portworxVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + } + ], + "description": "portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver when the CSIMigrationPortworx feature-gate is on." + }, + "projected": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + } + ], + "description": "projected items for all in one resources secrets, configmaps, and downward API" + }, + "quobyte": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + } + ], + "description": "quobyte represents a Quobyte mount on the host that shares a pod's lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported." + }, + "rbd": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + } + ], + "description": "rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported." + }, + "scaleIO": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + } + ], + "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + } + ], + "description": "secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret" + }, + "storageos": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + } + ], + "description": "storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported." + }, + "vsphereVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + ], + "description": "vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMountStatus": { + "description": "VolumeMountStatus shows status of volume mounts.", + "properties": { + "mountPath": { + "default": "", + "description": "MountPath corresponds to the original VolumeMount.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name corresponds to the name of the original VolumeMount.", + "type": "string" + }, + "readOnly": { + "description": "ReadOnly corresponds to the original VolumeMount.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly must be set to Disabled, Enabled, or unspecified (for non-readonly mounts). An IfPossible value in the original VolumeMount must be translated to Disabled or Enabled, depending on the mount result.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeNodeAffinity": { + "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.", + "properties": { + "required": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + ], + "description": "required specifies hard node constraints that must be met." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + } + ], + "description": "ClusterTrustBundle allows a pod to access the `.spec.trustBundle` field of ClusterTrustBundle objects in an auto-updating file.\n\nAlpha, gated by the ClusterTrustBundleProjection feature gate.\n\nClusterTrustBundle objects can either be selected by name, or by the combination of signer name and a label selector.\n\nKubelet performs aggressive normalization of the PEM contents written into the pod filesystem. Esoteric PEM features such as inter-block comments and block headers are stripped. Certificates are deduplicated. The ordering of certificates within the file is arbitrary, and Kubelet may change the order over time." + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + } + ], + "description": "configMap information about the configMap data to project" + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + } + ], + "description": "downwardAPI information about the downwardAPI data to project" + }, + "podCertificate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + } + ], + "description": "Projects an auto-rotating credential bundle (private key and certificate chain) that the pod can use either as a TLS client or server.\n\nKubelet generates a private key and uses it to send a PodCertificateRequest to the named signer. Once the signer approves the request and issues a certificate chain, Kubelet writes the key and certificate chain to the pod filesystem. The pod does not start until certificates have been issued for each podCertificate projected volume source in its spec.\n\nKubelet will begin trying to rotate the certificate at the time indicated by the signer using the PodCertificateRequest.Status.BeginRefreshAt timestamp.\n\nKubelet can write a single file, indicated by the credentialBundlePath field, or separate files, indicated by the keyPath and certificateChainPath fields.\n\nThe credential bundle is a single file in PEM format. The first PEM entry is the private key (in PKCS#8 format), and the remaining PEM entries are the certificate chain issued by the signer (typically, signers will return their certificate chain in leaf-to-root order).\n\nPrefer using the credential bundle format, since your application code can read it atomically. If you use keyPath and certificateChainPath, your application must make two separate file reads. If these coincide with a certificate rotation, it is possible that the private key and leaf certificate you read may not correspond to each other. Your application will need to check for this condition, and re-read until they are consistent.\n\nThe named signer controls chooses the format of the certificate it issues; consult the signer implementation's documentation to learn how to use the certificates it issues." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + } + ], + "description": "secret information about the secret data to project" + }, + "serviceAccountToken": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + ], + "description": "serviceAccountToken is information about the serviceAccountToken data to project" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {}, + "description": "Required. A pod affinity term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.api.policy.v1.Eviction": { + "description": "Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "deleteOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + ], + "description": "DeleteOptions may be provided" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "ObjectMeta describes the pod that is being evicted." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "Eviction", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable." + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/api/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCoreV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ] + } + }, + "/api/v1/componentstatuses": { + "get": { + "description": "list objects of kind ComponentStatus", + "operationId": "listCoreV1ComponentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/componentstatuses/{name}": { + "get": { + "description": "read the specified ComponentStatus", + "operationId": "readCoreV1ComponentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ComponentStatus", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/api/v1/configmaps": { + "get": { + "description": "list or watch objects of kind ConfigMap", + "operationId": "listCoreV1ConfigMapForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/endpoints": { + "get": { + "description": "list or watch objects of kind Endpoints", + "operationId": "listCoreV1EndpointsForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/events": { + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listCoreV1EventForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/limitranges": { + "get": { + "description": "list or watch objects of kind LimitRange", + "operationId": "listCoreV1LimitRangeForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/namespaces": { + "get": { + "description": "list or watch objects of kind Namespace", + "operationId": "listCoreV1Namespace", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Namespace", + "operationId": "createCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/bindings": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Binding", + "operationId": "createCoreV1NamespacedBinding", + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Binding", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/configmaps": { + "delete": { + "description": "delete collection of ConfigMap", + "operationId": "deleteCoreV1CollectionNamespacedConfigMap", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ConfigMap", + "operationId": "listCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ConfigMap", + "operationId": "createCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/configmaps/{name}": { + "delete": { + "description": "delete a ConfigMap", + "operationId": "deleteCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "get": { + "description": "read the specified ConfigMap", + "operationId": "readCoreV1NamespacedConfigMap", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ConfigMap", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ConfigMap", + "operationId": "patchCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ConfigMap", + "operationId": "replaceCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/endpoints": { + "delete": { + "description": "delete collection of Endpoints", + "operationId": "deleteCoreV1CollectionNamespacedEndpoints", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Endpoints", + "operationId": "listCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create Endpoints", + "operationId": "createCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/endpoints/{name}": { + "delete": { + "description": "delete Endpoints", + "operationId": "deleteCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "get": { + "description": "read the specified Endpoints", + "operationId": "readCoreV1NamespacedEndpoints", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Endpoints", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Endpoints", + "operationId": "patchCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Endpoints", + "operationId": "replaceCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/events": { + "delete": { + "description": "delete collection of Event", + "operationId": "deleteCoreV1CollectionNamespacedEvent", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listCoreV1NamespacedEvent", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Event", + "operationId": "createCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/events/{name}": { + "delete": { + "description": "delete an Event", + "operationId": "deleteCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "read the specified Event", + "operationId": "readCoreV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Event", + "operationId": "patchCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Event", + "operationId": "replaceCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/limitranges": { + "delete": { + "description": "delete collection of LimitRange", + "operationId": "deleteCoreV1CollectionNamespacedLimitRange", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind LimitRange", + "operationId": "listCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a LimitRange", + "operationId": "createCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/limitranges/{name}": { + "delete": { + "description": "delete a LimitRange", + "operationId": "deleteCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "get": { + "description": "read the specified LimitRange", + "operationId": "readCoreV1NamespacedLimitRange", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the LimitRange", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified LimitRange", + "operationId": "patchCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "put": { + "description": "replace the specified LimitRange", + "operationId": "replaceCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims": { + "delete": { + "description": "delete collection of PersistentVolumeClaim", + "operationId": "deleteCoreV1CollectionNamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PersistentVolumeClaim", + "operationId": "listCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PersistentVolumeClaim", + "operationId": "createCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}": { + "delete": { + "description": "delete a PersistentVolumeClaim", + "operationId": "deleteCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "get": { + "description": "read the specified PersistentVolumeClaim", + "operationId": "readCoreV1NamespacedPersistentVolumeClaim", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PersistentVolumeClaim", + "operationId": "patchCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PersistentVolumeClaim", + "operationId": "replaceCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status": { + "get": { + "description": "read status of the specified PersistentVolumeClaim", + "operationId": "readCoreV1NamespacedPersistentVolumeClaimStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PersistentVolumeClaim", + "operationId": "patchCoreV1NamespacedPersistentVolumeClaimStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PersistentVolumeClaim", + "operationId": "replaceCoreV1NamespacedPersistentVolumeClaimStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods": { + "delete": { + "description": "delete collection of Pod", + "operationId": "deleteCoreV1CollectionNamespacedPod", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Pod", + "operationId": "listCoreV1NamespacedPod", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Pod", + "operationId": "createCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}": { + "delete": { + "description": "delete a Pod", + "operationId": "deleteCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "get": { + "description": "read the specified Pod", + "operationId": "readCoreV1NamespacedPod", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Pod", + "operationId": "patchCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Pod", + "operationId": "replaceCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/attach": { + "get": { + "description": "connect GET requests to attach of Pod", + "operationId": "connectCoreV1GetNamespacedPodAttach", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodAttachOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "The container in which to execute the command. Defaults to only container if there is only one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the PodAttachOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true.", + "in": "query", + "name": "stderr", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false.", + "in": "query", + "name": "stdin", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true.", + "in": "query", + "name": "stdout", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "TTY if true indicates that a tty will be allocated for the attach call. This is passed through the container runtime so the tty is allocated on the worker node by the container runtime. Defaults to false.", + "in": "query", + "name": "tty", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to attach of Pod", + "operationId": "connectCoreV1PostNamespacedPodAttach", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodAttachOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/binding": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Binding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create binding of a Pod", + "operationId": "createCoreV1NamespacedPodBinding", + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Binding", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers": { + "get": { + "description": "read ephemeralcontainers of the specified Pod", + "operationId": "readCoreV1NamespacedPodEphemeralcontainers", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update ephemeralcontainers of the specified Pod", + "operationId": "patchCoreV1NamespacedPodEphemeralcontainers", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace ephemeralcontainers of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodEphemeralcontainers", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/eviction": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Eviction", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create eviction of a Pod", + "operationId": "createCoreV1NamespacedPodEviction", + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "Eviction", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/exec": { + "get": { + "description": "connect GET requests to exec of Pod", + "operationId": "connectCoreV1GetNamespacedPodExec", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodExecOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "Command is the remote command to execute. argv array. Not executed within a shell.", + "in": "query", + "name": "command", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Container in which to execute the command. Defaults to only container if there is only one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the PodExecOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard error stream of the pod for this call.", + "in": "query", + "name": "stderr", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard input stream of the pod for this call. Defaults to false.", + "in": "query", + "name": "stdin", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard output stream of the pod for this call.", + "in": "query", + "name": "stdout", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "TTY if true indicates that a tty will be allocated for the exec call. Defaults to false.", + "in": "query", + "name": "tty", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to exec of Pod", + "operationId": "connectCoreV1PostNamespacedPodExec", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodExecOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/log": { + "get": { + "description": "read log of the specified Pod", + "operationId": "readCoreV1NamespacedPodLog", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "type": "string" + } + }, + "application/json": { + "schema": { + "type": "string" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "type": "string" + } + }, + "application/yaml": { + "schema": { + "type": "string" + } + }, + "text/plain": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "The container for which to stream logs. Defaults to only container if there is one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Follow the log stream of the pod. Defaults to false.", + "in": "query", + "name": "follow", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "insecureSkipTLSVerifyBackend indicates that the apiserver should not confirm the validity of the serving certificate of the backend it is connecting to. This will make the HTTPS connection between the apiserver and the backend insecure. This means the apiserver cannot verify the log data it is receiving came from the real kubelet. If the kubelet is configured to verify the apiserver's TLS credentials, it does not mean the connection to the real kubelet is vulnerable to a man in the middle attack (e.g. an attacker could not intercept the actual log data coming from the real kubelet).", + "in": "query", + "name": "insecureSkipTLSVerifyBackend", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "If set, the number of bytes to read from the server before terminating the log output. This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit.", + "in": "query", + "name": "limitBytes", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Return previous terminated container logs. Defaults to false.", + "in": "query", + "name": "previous", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A relative time in seconds before the current time from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified.", + "in": "query", + "name": "sinceSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Specify which container log stream to return to the client. Acceptable values are \"All\", \"Stdout\" and \"Stderr\". If not specified, \"All\" is used, and both stdout and stderr are returned interleaved. Note that when \"TailLines\" is specified, \"Stream\" can only be set to nil or \"All\".", + "in": "query", + "name": "stream", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation of the container or sinceSeconds or sinceTime. Note that when \"TailLines\" is specified, \"Stream\" can only be set to nil or \"All\".", + "in": "query", + "name": "tailLines", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false.", + "in": "query", + "name": "timestamps", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/namespaces/{namespace}/pods/{name}/portforward": { + "get": { + "description": "connect GET requests to portforward of Pod", + "operationId": "connectCoreV1GetNamespacedPodPortforward", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodPortForwardOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodPortForwardOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "List of ports to forward Required when using WebSockets", + "in": "query", + "name": "ports", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to portforward of Pod", + "operationId": "connectCoreV1PostNamespacedPodPortforward", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodPortForwardOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Pod", + "operationId": "connectCoreV1DeleteNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Pod", + "operationId": "connectCoreV1GetNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Pod", + "operationId": "connectCoreV1HeadNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Pod", + "operationId": "connectCoreV1OptionsNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to pod.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Pod", + "operationId": "connectCoreV1PatchNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Pod", + "operationId": "connectCoreV1PostNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Pod", + "operationId": "connectCoreV1PutNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Pod", + "operationId": "connectCoreV1DeleteNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Pod", + "operationId": "connectCoreV1GetNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Pod", + "operationId": "connectCoreV1HeadNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Pod", + "operationId": "connectCoreV1OptionsNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to pod.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Pod", + "operationId": "connectCoreV1PatchNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Pod", + "operationId": "connectCoreV1PostNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Pod", + "operationId": "connectCoreV1PutNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/resize": { + "get": { + "description": "read resize of the specified Pod", + "operationId": "readCoreV1NamespacedPodResize", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update resize of the specified Pod", + "operationId": "patchCoreV1NamespacedPodResize", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace resize of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodResize", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/status": { + "get": { + "description": "read status of the specified Pod", + "operationId": "readCoreV1NamespacedPodStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Pod", + "operationId": "patchCoreV1NamespacedPodStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/podtemplates": { + "delete": { + "description": "delete collection of PodTemplate", + "operationId": "deleteCoreV1CollectionNamespacedPodTemplate", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PodTemplate", + "operationId": "listCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PodTemplate", + "operationId": "createCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/podtemplates/{name}": { + "delete": { + "description": "delete a PodTemplate", + "operationId": "deleteCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "get": { + "description": "read the specified PodTemplate", + "operationId": "readCoreV1NamespacedPodTemplate", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodTemplate", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PodTemplate", + "operationId": "patchCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PodTemplate", + "operationId": "replaceCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers": { + "delete": { + "description": "delete collection of ReplicationController", + "operationId": "deleteCoreV1CollectionNamespacedReplicationController", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ReplicationController", + "operationId": "listCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ReplicationController", + "operationId": "createCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}": { + "delete": { + "description": "delete a ReplicationController", + "operationId": "deleteCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "get": { + "description": "read the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationController", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale": { + "get": { + "description": "read scale of the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationControllerScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationControllerScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationControllerScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status": { + "get": { + "description": "read status of the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationControllerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationControllerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationControllerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas": { + "delete": { + "description": "delete collection of ResourceQuota", + "operationId": "deleteCoreV1CollectionNamespacedResourceQuota", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ResourceQuota", + "operationId": "listCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ResourceQuota", + "operationId": "createCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas/{name}": { + "delete": { + "description": "delete a ResourceQuota", + "operationId": "deleteCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "get": { + "description": "read the specified ResourceQuota", + "operationId": "readCoreV1NamespacedResourceQuota", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ResourceQuota", + "operationId": "patchCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ResourceQuota", + "operationId": "replaceCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status": { + "get": { + "description": "read status of the specified ResourceQuota", + "operationId": "readCoreV1NamespacedResourceQuotaStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ResourceQuota", + "operationId": "patchCoreV1NamespacedResourceQuotaStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ResourceQuota", + "operationId": "replaceCoreV1NamespacedResourceQuotaStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/secrets": { + "delete": { + "description": "delete collection of Secret", + "operationId": "deleteCoreV1CollectionNamespacedSecret", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Secret", + "operationId": "listCoreV1NamespacedSecret", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Secret", + "operationId": "createCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/secrets/{name}": { + "delete": { + "description": "delete a Secret", + "operationId": "deleteCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "get": { + "description": "read the specified Secret", + "operationId": "readCoreV1NamespacedSecret", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Secret", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Secret", + "operationId": "patchCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Secret", + "operationId": "replaceCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts": { + "delete": { + "description": "delete collection of ServiceAccount", + "operationId": "deleteCoreV1CollectionNamespacedServiceAccount", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ServiceAccount", + "operationId": "listCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ServiceAccount", + "operationId": "createCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts/{name}": { + "delete": { + "description": "delete a ServiceAccount", + "operationId": "deleteCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "get": { + "description": "read the specified ServiceAccount", + "operationId": "readCoreV1NamespacedServiceAccount", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceAccount", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ServiceAccount", + "operationId": "patchCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ServiceAccount", + "operationId": "replaceCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the TokenRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create token of a ServiceAccount", + "operationId": "createCoreV1NamespacedServiceAccountToken", + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "authentication.k8s.io", + "kind": "TokenRequest", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services": { + "delete": { + "description": "delete collection of Service", + "operationId": "deleteCoreV1CollectionNamespacedService", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Service", + "operationId": "listCoreV1NamespacedService", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Service", + "operationId": "createCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}": { + "delete": { + "description": "delete a Service", + "operationId": "deleteCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "get": { + "description": "read the specified Service", + "operationId": "readCoreV1NamespacedService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Service", + "operationId": "patchCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Service", + "operationId": "replaceCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Service", + "operationId": "connectCoreV1DeleteNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Service", + "operationId": "connectCoreV1GetNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Service", + "operationId": "connectCoreV1HeadNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Service", + "operationId": "connectCoreV1OptionsNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Service", + "operationId": "connectCoreV1PatchNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Service", + "operationId": "connectCoreV1PostNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Service", + "operationId": "connectCoreV1PutNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Service", + "operationId": "connectCoreV1DeleteNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Service", + "operationId": "connectCoreV1GetNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Service", + "operationId": "connectCoreV1HeadNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Service", + "operationId": "connectCoreV1OptionsNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Service", + "operationId": "connectCoreV1PatchNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Service", + "operationId": "connectCoreV1PostNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Service", + "operationId": "connectCoreV1PutNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/status": { + "get": { + "description": "read status of the specified Service", + "operationId": "readCoreV1NamespacedServiceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Service", + "operationId": "patchCoreV1NamespacedServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Service", + "operationId": "replaceCoreV1NamespacedServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}": { + "delete": { + "description": "delete a Namespace", + "operationId": "deleteCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "get": { + "description": "read the specified Namespace", + "operationId": "readCoreV1Namespace", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Namespace", + "operationId": "patchCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Namespace", + "operationId": "replaceCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}/finalize": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "put": { + "description": "replace finalize of the specified Namespace", + "operationId": "replaceCoreV1NamespaceFinalize", + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}/status": { + "get": { + "description": "read status of the specified Namespace", + "operationId": "readCoreV1NamespaceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Namespace", + "operationId": "patchCoreV1NamespaceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Namespace", + "operationId": "replaceCoreV1NamespaceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/nodes": { + "delete": { + "description": "delete collection of Node", + "operationId": "deleteCoreV1CollectionNode", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Node", + "operationId": "listCoreV1Node", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Node", + "operationId": "createCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}": { + "delete": { + "description": "delete a Node", + "operationId": "deleteCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "get": { + "description": "read the specified Node", + "operationId": "readCoreV1Node", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Node", + "operationId": "patchCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Node", + "operationId": "replaceCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Node", + "operationId": "connectCoreV1DeleteNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Node", + "operationId": "connectCoreV1GetNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Node", + "operationId": "connectCoreV1HeadNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Node", + "operationId": "connectCoreV1OptionsNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the NodeProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to node.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Node", + "operationId": "connectCoreV1PatchNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Node", + "operationId": "connectCoreV1PostNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Node", + "operationId": "connectCoreV1PutNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Node", + "operationId": "connectCoreV1DeleteNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Node", + "operationId": "connectCoreV1GetNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Node", + "operationId": "connectCoreV1HeadNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Node", + "operationId": "connectCoreV1OptionsNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the NodeProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to node.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Node", + "operationId": "connectCoreV1PatchNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Node", + "operationId": "connectCoreV1PostNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Node", + "operationId": "connectCoreV1PutNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/status": { + "get": { + "description": "read status of the specified Node", + "operationId": "readCoreV1NodeStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Node", + "operationId": "patchCoreV1NodeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Node", + "operationId": "replaceCoreV1NodeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumeclaims": { + "get": { + "description": "list or watch objects of kind PersistentVolumeClaim", + "operationId": "listCoreV1PersistentVolumeClaimForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/persistentvolumes": { + "delete": { + "description": "delete collection of PersistentVolume", + "operationId": "deleteCoreV1CollectionPersistentVolume", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PersistentVolume", + "operationId": "listCoreV1PersistentVolume", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PersistentVolume", + "operationId": "createCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumes/{name}": { + "delete": { + "description": "delete a PersistentVolume", + "operationId": "deleteCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "get": { + "description": "read the specified PersistentVolume", + "operationId": "readCoreV1PersistentVolume", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PersistentVolume", + "operationId": "patchCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PersistentVolume", + "operationId": "replaceCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumes/{name}/status": { + "get": { + "description": "read status of the specified PersistentVolume", + "operationId": "readCoreV1PersistentVolumeStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PersistentVolume", + "operationId": "patchCoreV1PersistentVolumeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PersistentVolume", + "operationId": "replaceCoreV1PersistentVolumeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/pods": { + "get": { + "description": "list or watch objects of kind Pod", + "operationId": "listCoreV1PodForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/podtemplates": { + "get": { + "description": "list or watch objects of kind PodTemplate", + "operationId": "listCoreV1PodTemplateForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/replicationcontrollers": { + "get": { + "description": "list or watch objects of kind ReplicationController", + "operationId": "listCoreV1ReplicationControllerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/resourcequotas": { + "get": { + "description": "list or watch objects of kind ResourceQuota", + "operationId": "listCoreV1ResourceQuotaForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/secrets": { + "get": { + "description": "list or watch objects of kind Secret", + "operationId": "listCoreV1SecretForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/serviceaccounts": { + "get": { + "description": "list or watch objects of kind ServiceAccount", + "operationId": "listCoreV1ServiceAccountForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/services": { + "get": { + "description": "list or watch objects of kind Service", + "operationId": "listCoreV1ServiceForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/configmaps": { + "get": { + "description": "watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ConfigMapListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/endpoints": { + "get": { + "description": "watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1EndpointsListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1EventListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/limitranges": { + "get": { + "description": "watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1LimitRangeListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces": { + "get": { + "description": "watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespaceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/configmaps": { + "get": { + "description": "watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedConfigMapList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/configmaps/{name}": { + "get": { + "description": "watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedConfigMap", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ConfigMap", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/endpoints": { + "get": { + "description": "watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedEndpointsList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/endpoints/{name}": { + "get": { + "description": "watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedEndpoints", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Endpoints", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedEventList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/events/{name}": { + "get": { + "description": "watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/limitranges": { + "get": { + "description": "watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedLimitRangeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/limitranges/{name}": { + "get": { + "description": "watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedLimitRange", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the LimitRange", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims": { + "get": { + "description": "watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPersistentVolumeClaimList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}": { + "get": { + "description": "watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPersistentVolumeClaim", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/pods": { + "get": { + "description": "watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPodList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/pods/{name}": { + "get": { + "description": "watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPod", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/podtemplates": { + "get": { + "description": "watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPodTemplateList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/podtemplates/{name}": { + "get": { + "description": "watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPodTemplate", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PodTemplate", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/replicationcontrollers": { + "get": { + "description": "watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedReplicationControllerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}": { + "get": { + "description": "watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedReplicationController", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/resourcequotas": { + "get": { + "description": "watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedResourceQuotaList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}": { + "get": { + "description": "watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedResourceQuota", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/secrets": { + "get": { + "description": "watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedSecretList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/secrets/{name}": { + "get": { + "description": "watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedSecret", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Secret", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/serviceaccounts": { + "get": { + "description": "watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedServiceAccountList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}": { + "get": { + "description": "watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedServiceAccount", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ServiceAccount", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/services": { + "get": { + "description": "watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedServiceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/services/{name}": { + "get": { + "description": "watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{name}": { + "get": { + "description": "watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1Namespace", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/nodes": { + "get": { + "description": "watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NodeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/nodes/{name}": { + "get": { + "description": "watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1Node", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumeclaims": { + "get": { + "description": "watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PersistentVolumeClaimListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumes": { + "get": { + "description": "watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PersistentVolumeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumes/{name}": { + "get": { + "description": "watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1PersistentVolume", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/pods": { + "get": { + "description": "watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PodListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/podtemplates": { + "get": { + "description": "watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PodTemplateListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/replicationcontrollers": { + "get": { + "description": "watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ReplicationControllerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/resourcequotas": { + "get": { + "description": "watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ResourceQuotaListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/secrets": { + "get": { + "description": "watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1SecretListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/serviceaccounts": { + "get": { + "description": "watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ServiceAccountListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/services": { + "get": { + "description": "watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ServiceListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/api_v1_patched.json b/gen/openapi_v1/specs/api_v1_patched.json new file mode 100644 index 00000000..cabf69ec --- /dev/null +++ b/gen/openapi_v1/specs/api_v1_patched.json @@ -0,0 +1,37515 @@ +{ + "components": { + "schemas": { + "io.k8s.api.authentication.v1.BoundObjectReference": { + "description": "BoundObjectReference is a reference to an object that a token is bound to.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. Valid kinds are 'Pod' and 'Secret'.", + "type": "string" + }, + "name": { + "description": "Name of the referent.", + "type": "string" + }, + "uid": { + "description": "UID of the referent.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.authentication.v1.TokenRequest": { + "description": "TokenRequest requests a token for a given service account.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "authentication.k8s.io", + "kind": "TokenRequest", + "version": "v1" + } + ] + }, + "io.k8s.api.authentication.v1.TokenRequestSpec": { + "description": "TokenRequestSpec contains client provided parameters of a token request.", + "properties": { + "audiences": { + "description": "Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "boundObjectRef": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference" + }, + "expirationSeconds": { + "description": "ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "audiences" + ], + "type": "object" + }, + "io.k8s.api.authentication.v1.TokenRequestStatus": { + "description": "TokenRequestStatus is the result of a token request.", + "properties": { + "expirationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "token": { + "default": "", + "description": "Token is the opaque bearer token.", + "type": "string" + } + }, + "required": [ + "token", + "expirationTimestamp" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v1.Scale": { + "description": "Scale represents a scaling request for a resource.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.ScaleSpec": { + "description": "ScaleSpec describes the attributes of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the desired number of instances for the scaled object.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.ScaleStatus": { + "description": "ScaleStatus represents the current status of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the actual number of observed instances of the scaled object.", + "format": "int32", + "type": "integer" + }, + "selector": { + "description": "selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/", + "type": "string" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + }, + "podAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + }, + "podAntiAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AttachedVolume": { + "description": "AttachedVolume describes a volume attached to a node", + "properties": { + "devicePath": { + "default": "", + "description": "DevicePath represents the device path where the volume should be available", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the attached volume", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFilePersistentVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "secretNamespace": { + "description": "secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure Share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Binding": { + "description": "Binding ties one object to another; for example, a pod is bound to a node by a scheduler.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + }, + "required": [ + "target" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Binding", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.CSIPersistentVolumeSource": { + "description": "Represents storage that is managed by an external CSI volume driver", + "properties": { + "controllerExpandSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "controllerPublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume. Required.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\".", + "type": "string" + }, + "nodeExpandSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "nodePublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "nodeStageSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "readOnly": { + "description": "readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes of the volume to publish.", + "type": "object" + }, + "volumeHandle": { + "default": "", + "description": "volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.", + "type": "string" + } + }, + "required": [ + "driver", + "volumeHandle" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSPersistentVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "user": { + "description": "user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderPersistentVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClientIPConfig": { + "description": "ClientIPConfig represents the configurations of Client IP based session affinity.", + "properties": { + "timeoutSeconds": { + "description": "timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \"ClientIP\". Default value is 10800(for 3 hours).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ComponentCondition": { + "description": "Information about the condition of a component.", + "properties": { + "error": { + "description": "Condition error code for a component. For example, a health check error code.", + "type": "string" + }, + "message": { + "description": "Message about the condition for a component. For example, information about a health check.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition for a component. Valid values for \"Healthy\": \"True\", \"False\", or \"Unknown\".", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of condition for a component. Valid value: \"Healthy\"", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ComponentStatus": { + "description": "ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "conditions": { + "description": "List of component conditions observed", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ComponentStatusList": { + "description": "Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ComponentStatus objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ComponentStatusList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMap": { + "description": "ConfigMap holds configuration data for pods to consume.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "binaryData": { + "additionalProperties": { + "format": "byte", + "type": "string" + }, + "description": "BinaryData contains the binary data. Each key must consist of alphanumeric characters, '-', '_' or '.'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet.", + "type": "object" + }, + "data": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Data contains the configuration data. Each key must consist of alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process.", + "type": "object" + }, + "immutable": { + "description": "Immutable, if set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapList": { + "description": "ConfigMapList is a resource containing a list of ConfigMap objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of ConfigMaps.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ConfigMapList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ConfigMapNodeConfigSource": { + "description": "ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration", + "properties": { + "kubeletConfigKey": { + "default": "", + "description": "KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the metadata.name of the referenced ConfigMap. This field is required in all cases.", + "type": "string" + }, + "namespace": { + "default": "", + "description": "Namespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases.", + "type": "string" + }, + "resourceVersion": { + "description": "ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.", + "type": "string" + }, + "uid": { + "description": "UID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.", + "type": "string" + } + }, + "required": [ + "namespace", + "name", + "kubeletConfigKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerExtendedResourceRequest": { + "description": "ContainerExtendedResourceRequest has the mapping of container name, extended resource name to the device request name.", + "properties": { + "containerName": { + "default": "", + "description": "The name of the container requesting resources.", + "type": "string" + }, + "requestName": { + "default": "", + "description": "The name of the request in the special ResourceClaim which corresponds to the extended resource.", + "type": "string" + }, + "resourceName": { + "default": "", + "description": "The name of the extended resource in that container which gets backed by DRA.", + "type": "string" + } + }, + "required": [ + "containerName", + "resourceName", + "requestName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerImage": { + "description": "Describe a container image", + "properties": { + "names": { + "description": "Names by which this image is known. e.g. [\"kubernetes.example/hyperkube:v1.0.7\", \"cloud-vendor.registry.example/cloud-vendor/hyperkube:v1.0.7\"]", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "sizeBytes": { + "description": "The size of the image in bytes.", + "format": "int64", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerState": { + "description": "ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.", + "properties": { + "running": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateRunning" + }, + "terminated": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated" + }, + "waiting": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateRunning": { + "description": "ContainerStateRunning is a running state of a container.", + "properties": { + "startedAt": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateTerminated": { + "description": "ContainerStateTerminated is a terminated state of a container.", + "properties": { + "containerID": { + "description": "Container's ID in the format '://'", + "type": "string" + }, + "exitCode": { + "default": 0, + "description": "Exit status from the last termination of the container", + "format": "int32", + "type": "integer" + }, + "finishedAt": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Message regarding the last termination of the container", + "type": "string" + }, + "reason": { + "description": "(brief) reason from the last termination of the container", + "type": "string" + }, + "signal": { + "description": "Signal from the last termination of the container", + "format": "int32", + "type": "integer" + }, + "startedAt": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "required": [ + "exitCode" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStateWaiting": { + "description": "ContainerStateWaiting is a waiting state of a container.", + "properties": { + "message": { + "description": "Message regarding why the container is not yet running.", + "type": "string" + }, + "reason": { + "description": "(brief) reason the container is not yet running.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ContainerStatus": { + "description": "ContainerStatus contains details for the current status of this container.", + "properties": { + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "AllocatedResources represents the compute resources allocated for this container by the node. Kubelet sets this value to Container.Resources.Requests upon successful pod admission and after successfully admitting desired pod resize.", + "type": "object" + }, + "allocatedResourcesStatus": { + "description": "AllocatedResourcesStatus represents the status of various resources allocated for this Pod.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceStatus" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "containerID": { + "description": "ContainerID is the ID of the container in the format '://'. Where type is a container runtime identifier, returned from Version call of CRI API (for example \"containerd\").", + "type": "string" + }, + "image": { + "default": "", + "description": "Image is the name of container image that the container is running. The container image may not match the image used in the PodSpec, as it may have been resolved by the runtime. More info: https://kubernetes.io/docs/concepts/containers/images.", + "type": "string" + }, + "imageID": { + "default": "", + "description": "ImageID is the image ID of the container's image. The image ID may not match the image ID of the image used in the PodSpec, as it may have been resolved by the runtime.", + "type": "string" + }, + "lastState": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerState" + }, + "name": { + "default": "", + "description": "Name is a DNS_LABEL representing the unique name of the container. Each container in a pod must have a unique name across all container types. Cannot be updated.", + "type": "string" + }, + "ready": { + "default": false, + "description": "Ready specifies whether the container is currently passing its readiness check. The value will change as readiness probes keep executing. If no readiness probes are specified, this field defaults to true once the container is fully started (see Started field).\n\nThe value is typically used to determine whether a container is ready to accept traffic.", + "type": "boolean" + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartCount": { + "default": 0, + "description": "RestartCount holds the number of times the container has been restarted. Kubelet makes an effort to always increment the value, but there are cases when the state may be lost due to node restarts and then the value may be reset to 0. The value is never negative.", + "format": "int32", + "type": "integer" + }, + "started": { + "description": "Started indicates whether the container has finished its postStart lifecycle hook and passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. In both cases, startup probes will run again. Is always true when no startupProbe is defined and container is running and has passed the postStart lifecycle hook. The null value must be treated the same as false.", + "type": "boolean" + }, + "state": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerState" + }, + "stopSignal": { + "description": "StopSignal reports the effective stop signal for this container", + "type": "string" + }, + "user": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerUser" + }, + "volumeMounts": { + "description": "Status of volume mounts.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMountStatus" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "required": [ + "name", + "ready", + "restartCount", + "image", + "imageID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerUser": { + "description": "ContainerUser represents user identity information", + "properties": { + "linux": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LinuxContainerUser" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DaemonEndpoint": { + "description": "DaemonEndpoint contains information about a single Daemon endpoint.", + "properties": { + "Port": { + "default": 0, + "description": "Port number of the given endpoint.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "Port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EndpointAddress": { + "description": "EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "hostname": { + "description": "The Hostname of this endpoint", + "type": "string" + }, + "ip": { + "default": "", + "description": "The IP of this endpoint. May not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10), or link-local multicast (224.0.0.0/24 or ff02::/16).", + "type": "string" + }, + "nodeName": { + "description": "Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.", + "type": "string" + }, + "targetRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + }, + "required": [ + "ip" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.EndpointPort": { + "description": "EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "The name of this port. This must match the 'name' field in the corresponding ServicePort. Must be a DNS_LABEL. Optional only if one port is defined.", + "type": "string" + }, + "port": { + "default": 0, + "description": "The port number of the endpoint.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "description": "The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.EndpointSubset": { + "description": "EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given:\n\n\t{\n\t Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}]\n\t}\n\nThe resulting set of endpoints can be viewed as:\n\n\ta: [ 10.10.1.1:8675, 10.10.2.2:8675 ],\n\tb: [ 10.10.1.1:309, 10.10.2.2:309 ]\n\nDeprecated: This API is deprecated in v1.33+.", + "properties": { + "addresses": { + "description": "IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointAddress" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "notReadyAddresses": { + "description": "IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointAddress" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ports": { + "description": "Port numbers available on the related IP addresses.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointPort" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Endpoints": { + "description": "Endpoints is a collection of endpoints that implement the actual service. Example:\n\n\t Name: \"mysvc\",\n\t Subsets: [\n\t {\n\t Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}]\n\t },\n\t {\n\t Addresses: [{\"ip\": \"10.10.3.3\"}],\n\t Ports: [{\"name\": \"a\", \"port\": 93}, {\"name\": \"b\", \"port\": 76}]\n\t },\n\t]\n\nEndpoints is a legacy API and does not contain information about all Service features. Use discoveryv1.EndpointSlice for complete information about Service endpoints.\n\nDeprecated: This API is deprecated in v1.33+. Use discoveryv1.EndpointSlice.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "subsets": { + "description": "The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointSubset" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EndpointsList": { + "description": "EndpointsList is a list of endpoints. Deprecated: This API is deprecated in v1.33+.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of endpoints.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "EndpointsList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + }, + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "fileKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + }, + "secretKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Event": { + "description": "Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.", + "properties": { + "action": { + "description": "What action was taken/failed regarding to the Regarding object.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "count": { + "description": "The number of times this event has occurred.", + "format": "int32", + "type": "integer" + }, + "eventTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + }, + "firstTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "involvedObject": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "lastTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "reason": { + "description": "This should be a short, machine understandable string that gives the reason for the transition into the object's current status.", + "type": "string" + }, + "related": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "reportingComponent": { + "default": "", + "description": "Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.", + "type": "string" + }, + "reportingInstance": { + "default": "", + "description": "ID of the controller instance, e.g. `kubelet-xyzf`.", + "type": "string" + }, + "series": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSeries" + }, + "source": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSource" + }, + "type": { + "description": "Type of this event (Normal, Warning), new types could be added in the future", + "type": "string" + } + }, + "required": [ + "metadata", + "involvedObject" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Event", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EventList": { + "description": "EventList is a list of events.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of events", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "EventList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.EventSeries": { + "description": "EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.", + "properties": { + "count": { + "description": "Number of occurrences in this series up to the last heartbeat time", + "format": "int32", + "type": "integer" + }, + "lastObservedTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EventSource": { + "description": "EventSource contains information for an event.", + "properties": { + "component": { + "description": "Component from which the event is generated.", + "type": "string" + }, + "host": { + "description": "Node name on which the event is generated.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexPersistentVolumeSource": { + "description": "FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsPersistentVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "endpointsNamespace": { + "description": "endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostIP": { + "description": "HostIP represents a single IP address allocated to the host.", + "properties": { + "ip": { + "default": "", + "description": "IP is the IP address assigned to the host", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIPersistentVolumeSource": { + "description": "ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is Target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun is iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "preStop": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "sleep": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LimitRange": { + "description": "LimitRange sets resource usage limits for each kind of resource in a Namespace.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeSpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.LimitRangeItem": { + "description": "LimitRangeItem defines a min/max usage limit for any resource that matches on kind.", + "properties": { + "default": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Default resource requirement limit value by resource name if resource limit is omitted.", + "type": "object" + }, + "defaultRequest": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "DefaultRequest is the default resource requirement request value by resource name if resource request is omitted.", + "type": "object" + }, + "max": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Max usage constraints on this kind by resource name.", + "type": "object" + }, + "maxLimitRequestRatio": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.", + "type": "object" + }, + "min": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Min usage constraints on this kind by resource name.", + "type": "object" + }, + "type": { + "default": "", + "description": "Type of resource that this limit applies to.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LimitRangeList": { + "description": "LimitRangeList is a list of LimitRange items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "LimitRangeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.LimitRangeSpec": { + "description": "LimitRangeSpec defines a min/max usage limit for resources that match on kind.", + "properties": { + "limits": { + "description": "Limits is the list of LimitRangeItem objects that are enforced.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeItem" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "limits" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LinuxContainerUser": { + "description": "LinuxContainerUser represents user identity information in Linux containers", + "properties": { + "gid": { + "default": 0, + "description": "GID is the primary gid initially attached to the first process in the container", + "format": "int64", + "type": "integer" + }, + "supplementalGroups": { + "description": "SupplementalGroups are the supplemental groups initially attached to the first process in the container", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "uid": { + "default": 0, + "description": "UID is the primary uid initially attached to the first process in the container", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "uid", + "gid" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LoadBalancerIngress": { + "description": "LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point.", + "properties": { + "hostname": { + "description": "Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers)", + "type": "string" + }, + "ip": { + "description": "IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers)", + "type": "string" + }, + "ipMode": { + "description": "IPMode specifies how the load-balancer IP behaves, and may only be specified when the ip field is specified. Setting this to \"VIP\" indicates that traffic is delivered to the node with the destination set to the load-balancer's IP and port. Setting this to \"Proxy\" indicates that traffic is delivered to the node or pod with the destination set to the node's IP and node port or the pod's IP and port. Service implementations may use this information to adjust traffic routing.", + "type": "string" + }, + "ports": { + "description": "Ports is a list of records of service ports If used, every port defined in the service should have an entry in it", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LoadBalancerStatus": { + "description": "LoadBalancerStatus represents the status of a load-balancer.", + "properties": { + "ingress": { + "description": "Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.LocalVolumeSource": { + "description": "Local represents directly-attached storage with node affinity", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a filesystem if unspecified.", + "type": "string" + }, + "path": { + "default": "", + "description": "path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ModifyVolumeStatus": { + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation", + "properties": { + "status": { + "default": "", + "description": "status is the status of the ControllerModifyVolume operation. It can be in any of following states:\n - Pending\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\n the specified VolumeAttributesClass not existing.\n - InProgress\n InProgress indicates that the volume is being modified.\n - Infeasible\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\n\t resolve the error, a valid VolumeAttributesClass needs to be specified.\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.", + "type": "string" + }, + "targetVolumeAttributesClassName": { + "description": "targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled", + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Namespace": { + "description": "Namespace provides a scope for Names. Use of multiple namespaces is optional.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Namespace", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NamespaceCondition": { + "description": "NamespaceCondition contains details about state of namespace.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of namespace controller condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NamespaceList": { + "description": "NamespaceList is a list of Namespaces.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "NamespaceList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NamespaceSpec": { + "description": "NamespaceSpec describes the attributes on a Namespace.", + "properties": { + "finalizers": { + "description": "Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NamespaceStatus": { + "description": "NamespaceStatus is information about the current status of a Namespace.", + "properties": { + "conditions": { + "description": "Represents the latest available observations of a namespace's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "phase": { + "description": "Phase is the current lifecycle phase of the namespace. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Node": { + "description": "Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd).", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Node", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NodeAddress": { + "description": "NodeAddress contains information for the node's address.", + "properties": { + "address": { + "default": "", + "description": "The node address.", + "type": "string" + }, + "type": { + "default": "", + "description": "Node address type, one of Hostname, ExternalIP or InternalIP.", + "type": "string" + } + }, + "required": [ + "type", + "address" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeCondition": { + "description": "NodeCondition contains condition information for a node.", + "properties": { + "lastHeartbeatTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Human readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "(brief) reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of node condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeConfigSource": { + "description": "NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. This API is deprecated since 1.22", + "properties": { + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeConfigStatus": { + "description": "NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource.", + "properties": { + "active": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + }, + "assigned": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + }, + "error": { + "description": "Error describes any problems reconciling the Spec.ConfigSource to the Active config. Errors may occur, for example, attempting to checkpoint Spec.ConfigSource to the local Assigned record, attempting to checkpoint the payload associated with Spec.ConfigSource, attempting to load or validate the Assigned config, etc. Errors may occur at different points while syncing config. Earlier errors (e.g. download or checkpointing errors) will not result in a rollback to LastKnownGood, and may resolve across Kubelet retries. Later errors (e.g. loading or validating a checkpointed config) will result in a rollback to LastKnownGood. In the latter case, it is usually possible to resolve the error by fixing the config assigned in Spec.ConfigSource. You can find additional information for debugging by searching the error message in the Kubelet log. Error is a human-readable description of the error state; machines can check whether or not Error is empty, but should not rely on the stability of the Error text across Kubelet versions.", + "type": "string" + }, + "lastKnownGood": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeDaemonEndpoints": { + "description": "NodeDaemonEndpoints lists ports opened by daemons running on the Node.", + "properties": { + "kubeletEndpoint": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DaemonEndpoint" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeFeatures": { + "description": "NodeFeatures describes the set of features implemented by the CRI implementation. The features contained in the NodeFeatures should depend only on the cri implementation independent of runtime handlers.", + "properties": { + "supplementalGroupsPolicy": { + "description": "SupplementalGroupsPolicy is set to true if the runtime supports SupplementalGroupsPolicy and ContainerUser.", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeList": { + "description": "NodeList is the whole list of all Nodes which have been registered with master.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of nodes", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "NodeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.NodeRuntimeHandler": { + "description": "NodeRuntimeHandler is a set of runtime handler information.", + "properties": { + "features": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures" + }, + "name": { + "default": "", + "description": "Runtime handler name. Empty for the default runtime handler.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeRuntimeHandlerFeatures": { + "description": "NodeRuntimeHandlerFeatures is a set of features implemented by the runtime handler.", + "properties": { + "recursiveReadOnlyMounts": { + "description": "RecursiveReadOnlyMounts is set to true if the runtime handler supports RecursiveReadOnlyMounts.", + "type": "boolean" + }, + "userNamespaces": { + "description": "UserNamespaces is set to true if the runtime handler supports UserNamespaces, including for volumes.", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSpec": { + "description": "NodeSpec describes the attributes that a node is created with.", + "properties": { + "configSource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigSource" + }, + "externalID": { + "description": "Deprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966", + "type": "string" + }, + "podCIDR": { + "description": "PodCIDR represents the pod IP range assigned to the node.", + "type": "string" + }, + "podCIDRs": { + "description": "podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "providerID": { + "description": "ID of the node assigned by the cloud provider in the format: ://", + "type": "string" + }, + "taints": { + "description": "If specified, the node's taints.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Taint" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "unschedulable": { + "description": "Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeStatus": { + "description": "NodeStatus is information about the current status of a node.", + "properties": { + "addresses": { + "description": "List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/reference/node/node-status/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. Consumers should assume that addresses can change during the lifetime of a Node. However, there are some exceptions where this may not be possible, such as Pods that inherit a Node's address in its own status or consumers of the downward API (status.hostIP).", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAddress" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "allocatable": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/reference/node/node-status/#capacity", + "type": "object" + }, + "conditions": { + "description": "Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/reference/node/node-status/#condition", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "config": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeConfigStatus" + }, + "daemonEndpoints": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints" + }, + "declaredFeatures": { + "description": "DeclaredFeatures represents the features related to feature gates that are declared by the node.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "features": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeFeatures" + }, + "images": { + "description": "List of container images on this node", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerImage" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "nodeInfo": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSystemInfo" + }, + "phase": { + "description": "NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated.", + "type": "string" + }, + "runtimeHandlers": { + "description": "The available runtime handlers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "volumesAttached": { + "description": "List of volumes that are attached to the node.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AttachedVolume" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "volumesInUse": { + "description": "List of attachable volumes in use (mounted) by the node.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSwapStatus": { + "description": "NodeSwapStatus represents swap memory information.", + "properties": { + "capacity": { + "description": "Total amount of swap memory in bytes.", + "format": "int64", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSystemInfo": { + "description": "NodeSystemInfo is a set of ids/uuids to uniquely identify the node.", + "properties": { + "architecture": { + "default": "", + "description": "The Architecture reported by the node", + "type": "string" + }, + "bootID": { + "default": "", + "description": "Boot ID reported by the node.", + "type": "string" + }, + "containerRuntimeVersion": { + "default": "", + "description": "ContainerRuntime Version reported by the node through runtime remote API (e.g. containerd://1.4.2).", + "type": "string" + }, + "kernelVersion": { + "default": "", + "description": "Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64).", + "type": "string" + }, + "kubeProxyVersion": { + "default": "", + "description": "Deprecated: KubeProxy Version reported by the node.", + "type": "string" + }, + "kubeletVersion": { + "default": "", + "description": "Kubelet Version reported by the node.", + "type": "string" + }, + "machineID": { + "default": "", + "description": "MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html", + "type": "string" + }, + "operatingSystem": { + "default": "", + "description": "The Operating System reported by the node", + "type": "string" + }, + "osImage": { + "default": "", + "description": "OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).", + "type": "string" + }, + "swap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSwapStatus" + }, + "systemUUID": { + "default": "", + "description": "SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid", + "type": "string" + } + }, + "required": [ + "machineID", + "systemUUID", + "bootID", + "kernelVersion", + "osImage", + "containerRuntimeVersion", + "kubeletVersion", + "kubeProxyVersion", + "operatingSystem", + "architecture" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolume": { + "description": "PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaim": { + "description": "PersistentVolumeClaim is a user's request for and claim to a persistent volume", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimCondition": { + "description": "PersistentVolumeClaimCondition contains details about state of pvc", + "properties": { + "lastProbeTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message is the human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"Resizing\" that means the underlying persistent volume is being resized.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimList": { + "description": "PersistentVolumeClaimList is a list of PersistentVolumeClaim items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaimList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "dataSource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + }, + "dataSourceRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimStatus": { + "description": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "properties": { + "accessModes": { + "description": "accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "allocatedResourceStatuses": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nClaimResourceStatus can be in any of following states:\n\t- ControllerResizeInProgress:\n\t\tState set when resize controller starts resizing the volume in control-plane.\n\t- ControllerResizeFailed:\n\t\tState set when resize has failed in resize controller with a terminal error.\n\t- NodeResizePending:\n\t\tState set when resize controller has finished resizing the volume but further resizing of\n\t\tvolume is needed on the node.\n\t- NodeResizeInProgress:\n\t\tState set when kubelet starts resizing the volume.\n\t- NodeResizeFailed:\n\t\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\n\t\tNodeResizeFailed.\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\n\t- pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeFailed\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizePending\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeFailed\"\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\n\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object", + "x-kubernetes-map-type": "granular" + }, + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\n\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity represents the actual resources of the underlying volume.", + "type": "object" + }, + "conditions": { + "description": "conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentVolumeAttributesClassName": { + "description": "currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim", + "type": "string" + }, + "modifyVolumeStatus": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus" + }, + "phase": { + "description": "phase represents the current phase of PersistentVolumeClaim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeList": { + "description": "PersistentVolumeList is a list of PersistentVolume items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeSpec": { + "description": "PersistentVolumeSpec is the specification of a persistent volume.", + "properties": { + "accessModes": { + "description": "accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "awsElasticBlockStore": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + }, + "azureDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + }, + "azureFile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity", + "type": "object" + }, + "cephfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource" + }, + "cinder": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource" + }, + "claimRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "csi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource" + }, + "fc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + }, + "flexVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource" + }, + "flocker": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + }, + "gcePersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + }, + "glusterfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource" + }, + "hostPath": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + }, + "iscsi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource" + }, + "local": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource" + }, + "mountOptions": { + "description": "mountOptions is the list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "nfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + }, + "nodeAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity" + }, + "persistentVolumeReclaimPolicy": { + "description": "persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming", + "type": "string" + }, + "photonPersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + }, + "portworxVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + }, + "quobyte": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + }, + "rbd": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource" + }, + "scaleIO": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource" + }, + "storageClassName": { + "description": "storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.", + "type": "string" + }, + "storageos": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource" + }, + "volumeAttributesClassName": { + "description": "Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.", + "type": "string" + }, + "vsphereVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeStatus": { + "description": "PersistentVolumeStatus is the current status of a persistent volume.", + "properties": { + "lastPhaseTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message is a human-readable message indicating details about why the volume is in this state.", + "type": "string" + }, + "phase": { + "description": "phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase", + "type": "string" + }, + "reason": { + "description": "reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Pod": { + "description": "Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Pod", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "namespaceSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodCondition": { + "description": "PodCondition contains details for the current condition of this pod.", + "properties": { + "lastProbeTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "observedGeneration": { + "description": "If set, this represents the .metadata.generation that the pod condition was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.", + "format": "int64", + "type": "integer" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodExtendedResourceClaimStatus": { + "description": "PodExtendedResourceClaimStatus is stored in the PodStatus for the extended resource requests backed by DRA. It stores the generated name for the corresponding special ResourceClaim created by the scheduler.", + "properties": { + "requestMappings": { + "description": "RequestMappings identifies the mapping of to device request in the generated ResourceClaim.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resourceClaimName": { + "default": "", + "description": "ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod.", + "type": "string" + } + }, + "required": [ + "requestMappings", + "resourceClaimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodIP": { + "description": "PodIP represents a single IP address allocated to the pod.", + "properties": { + "ip": { + "default": "", + "description": "IP is the IP address assigned to the pod", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodList": { + "description": "PodList is a list of Pods.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pods. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaimStatus": { + "description": "PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must match the name of an entry in pod.spec.resourceClaims, which implies that the string must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod. If this is unset, then generating a ResourceClaim was not necessary. The pod.spec.resourceClaims entry can be ignored in this case.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "dnsConfig": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "workloadRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodStatus": { + "description": "PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane.", + "properties": { + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "AllocatedResources is the total requests allocated for this pod by the node. If pod-level requests are not set, this will be the total requests aggregated across containers in the pod.", + "type": "object" + }, + "conditions": { + "description": "Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "containerStatuses": { + "description": "Statuses of containers in this pod. Each container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ephemeralContainerStatuses": { + "description": "Statuses for any ephemeral containers that have run in this pod. Each ephemeral container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "extendedResourceClaimStatus": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus" + }, + "hostIP": { + "description": "hostIP holds the IP address of the host to which the pod is assigned. Empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns mean that HostIP will not be updated even if there is a node is assigned to pod", + "type": "string" + }, + "hostIPs": { + "description": "hostIPs holds the IP addresses allocated to the host. If this field is specified, the first entry must match the hostIP field. This list is empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns means that HostIPs will not be updated even if there is a node is assigned to this pod.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostIP" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "initContainerStatuses": { + "description": "Statuses of init containers in this pod. The most recent successful non-restartable init container will have ready = true, the most recently started container will have startTime set. Each init container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-and-container-status", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "message": { + "description": "A human readable message indicating details about why the pod is in this condition.", + "type": "string" + }, + "nominatedNodeName": { + "description": "nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.", + "type": "string" + }, + "observedGeneration": { + "description": "If set, this represents the .metadata.generation that the pod status was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.", + "format": "int64", + "type": "integer" + }, + "phase": { + "description": "The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:\n\nPending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod.\n\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase", + "type": "string" + }, + "podIP": { + "description": "podIP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.", + "type": "string" + }, + "podIPs": { + "description": "podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodIP" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "qosClass": { + "description": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/#quality-of-service-classes", + "type": "string" + }, + "reason": { + "description": "A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted'", + "type": "string" + }, + "resize": { + "description": "Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to \"Proposed\" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.", + "type": "string" + }, + "resourceClaimStatuses": { + "description": "Status of resource claims.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "startTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplate": { + "description": "PodTemplate describes a template for creating copies of a predefined pod.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodTemplateList": { + "description": "PodTemplateList is a list of PodTemplates.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pod templates", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PodTemplateList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortStatus": { + "description": "PortStatus represents the error condition of a service port", + "properties": { + "error": { + "description": "Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\n CamelCase names\n- cloud provider specific error values must have names that comply with the\n format foo.example.com/CamelCase.", + "type": "string" + }, + "port": { + "default": 0, + "description": "Port is the port number of the service port of which status is recorded here", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "", + "description": "Protocol is the protocol of the service port of which status is recorded here The supported values are: \"TCP\", \"UDP\", \"SCTP\"", + "type": "string" + } + }, + "required": [ + "port", + "protocol" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDPersistentVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationController": { + "description": "ReplicationController represents the configuration of a replication controller.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ReplicationControllerCondition": { + "description": "ReplicationControllerCondition describes the state of a replication controller at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of replication controller condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationControllerList": { + "description": "ReplicationControllerList is a collection of replication controllers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ReplicationControllerList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ReplicationControllerSpec": { + "description": "ReplicationControllerSpec is the specification of a replication controller.", + "properties": { + "minReadySeconds": { + "default": 0, + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 1, + "description": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller", + "format": "int32", + "type": "integer" + }, + "selector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ReplicationControllerStatus": { + "description": "ReplicationControllerStatus represents the current status of a replication controller.", + "properties": { + "availableReplicas": { + "description": "The number of available replicas (ready for at least minReadySeconds) for this replication controller.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a replication controller's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "fullyLabeledReplicas": { + "description": "The number of pods that have labels matching the labels of the pod template of the replication controller.", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "ObservedGeneration reflects the generation of the most recently observed replication controller.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "The number of ready replicas for this replication controller.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "Replicas is the most recently observed number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceHealth": { + "description": "ResourceHealth represents the health of a resource. It has the latest device health information. This is a part of KEP https://kep.k8s.io/4680.", + "properties": { + "health": { + "description": "Health of the resource. can be one of:\n - Healthy: operates as normal\n - Unhealthy: reported unhealthy. We consider this a temporary health issue\n since we do not have a mechanism today to distinguish\n temporary and permanent issues.\n - Unknown: The status cannot be determined.\n For example, Device Plugin got unregistered and hasn't been re-registered since.\n\nIn future we may want to introduce the PermanentlyUnhealthy Status.", + "type": "string" + }, + "resourceID": { + "default": "", + "description": "ResourceID is the unique identifier of the resource. See the ResourceID type for more information.", + "type": "string" + } + }, + "required": [ + "resourceID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceQuota": { + "description": "ResourceQuota sets aggregate quota restrictions enforced per namespace", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ResourceQuotaList": { + "description": "ResourceQuotaList is a list of ResourceQuota items.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ResourceQuotaList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ResourceQuotaSpec": { + "description": "ResourceQuotaSpec defines the desired hard limits to enforce for Quota.", + "properties": { + "hard": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "type": "object" + }, + "scopeSelector": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScopeSelector" + }, + "scopes": { + "description": "A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceQuotaStatus": { + "description": "ResourceQuotaStatus defines the enforced hard limits and observed use.", + "properties": { + "hard": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/", + "type": "object" + }, + "used": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Used is the current observed total usage of the resource in the namespace.", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "nullable": true + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ResourceStatus": { + "description": "ResourceStatus represents the status of a single resource allocated to a Pod.", + "properties": { + "name": { + "default": "", + "description": "Name of the resource. Must be unique within the pod and in case of non-DRA resource, match one of the resources from the pod spec. For DRA resources, the value must be \"claim:/\". When this status is reported about a container, the \"claim_name\" and \"request\" must match one of the claims of this container.", + "type": "string" + }, + "resources": { + "description": "List of unique resources health. Each element in the list contains an unique resource ID and its health. At a minimum, for the lifetime of a Pod, resource ID must uniquely identify the resource allocated to the Pod on the Node. If other Pod on the same Node reports the status with the same resource ID, it must be the same resource they share. See ResourceID type definition for a specific format it has in various use cases.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceHealth" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "resourceID" + ], + "x-kubernetes-list-type": "map", + "nullable": true + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOPersistentVolumeSource": { + "description": "ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\"", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "sslEnabled": { + "description": "sslEnabled is the flag to enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScopeSelector": { + "description": "A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements.", + "properties": { + "matchExpressions": { + "description": "A list of scope selector requirements by scope of the resources.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ScopedResourceSelectorRequirement": { + "description": "A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values.", + "properties": { + "operator": { + "default": "", + "description": "Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist.", + "type": "string" + }, + "scopeName": { + "default": "", + "description": "The name of the scope that the selector applies to.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "scopeName", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.Secret": { + "description": "Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "data": { + "additionalProperties": { + "format": "byte", + "type": "string" + }, + "description": "Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4", + "type": "object" + }, + "immutable": { + "description": "Immutable, if set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "stringData": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "stringData allows specifying non-binary secret data in string form. It is provided as a write-only input field for convenience. All keys and values are merged into the data field on write, overwriting any existing values. The stringData field is never output when reading from the API.", + "type": "object" + }, + "type": { + "description": "Used to facilitate programmatic handling of secret data. More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Secret", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretList": { + "description": "SecretList is a list of Secret.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "SecretList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretReference": { + "description": "SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace", + "properties": { + "name": { + "description": "name is unique within a namespace to reference a secret resource.", + "type": "string" + }, + "namespace": { + "description": "namespace defines the space within which the secret name must be unique.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "capabilities": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Service": { + "description": "Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Service", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccount": { + "description": "ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level.", + "type": "boolean" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "secrets": { + "description": "Secrets is a list of the secrets in the same namespace that pods running using this ServiceAccount are allowed to use. Pods are only limited to this list if this service account has a \"kubernetes.io/enforce-mountable-secrets\" annotation set to \"true\". The \"kubernetes.io/enforce-mountable-secrets\" annotation is deprecated since v1.32. Prefer separate namespaces to isolate access to mounted secrets. This field should not be used to find auto-generated service account token secrets for use outside of pods. Instead, tokens can be requested directly using the TokenRequest API, or service account token secrets can be manually created. More info: https://kubernetes.io/docs/concepts/configuration/secret", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccountList": { + "description": "ServiceAccountList is a list of ServiceAccount objects", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceAccountList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ServiceList": { + "description": "ServiceList holds a list of services.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of services", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "ServiceList", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.ServicePort": { + "description": "ServicePort contains information on service's port.", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. When considering the endpoints for a Service, this must match the 'name' field in the EndpointPort. Optional if only one ServicePort is defined on this service.", + "type": "string" + }, + "nodePort": { + "description": "The port on each node on which this service is exposed when type is NodePort or LoadBalancer. Usually assigned by the system. If a value is specified, in-range, and not in use it will be used, otherwise the operation will fail. If not specified, a port will be allocated if this Service requires one. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type from NodePort to ClusterIP). More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport", + "format": "int32", + "type": "integer" + }, + "port": { + "default": 0, + "description": "The port that will be exposed by this service.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "TCP", + "description": "The IP protocol for this port. Supports \"TCP\", \"UDP\", and \"SCTP\". Default is TCP.", + "type": "string" + }, + "targetPort": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ServiceSpec": { + "description": "ServiceSpec describes the attributes that a user creates on a service.", + "properties": { + "allocateLoadBalancerNodePorts": { + "description": "allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is \"true\". It may be set to \"false\" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type.", + "type": "boolean" + }, + "clusterIP": { + "description": "clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "type": "string" + }, + "clusterIPs": { + "description": "ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\n\nThis field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "externalIPs": { + "description": "externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "externalName": { + "description": "externalName is the external reference that discovery mechanisms will return as an alias for this service (e.g. a DNS CNAME record). No proxying will be involved. Must be a lowercase RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires `type` to be \"ExternalName\".", + "type": "string" + }, + "externalTrafficPolicy": { + "description": "externalTrafficPolicy describes how nodes distribute service traffic they receive on one of the Service's \"externally-facing\" addresses (NodePorts, ExternalIPs, and LoadBalancer IPs). If set to \"Local\", the proxy will configure the service in a way that assumes that external load balancers will take care of balancing the service traffic between nodes, and so each node will deliver traffic only to the node-local endpoints of the service, without masquerading the client source IP. (Traffic mistakenly sent to a node with no endpoints will be dropped.) The default value, \"Cluster\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features). Note that traffic sent to an External IP or LoadBalancer IP from within the cluster will always get \"Cluster\" semantics, but clients sending to a NodePort from within the cluster may need to take traffic policy into account when picking a node.", + "type": "string" + }, + "healthCheckNodePort": { + "description": "healthCheckNodePort specifies the healthcheck nodePort for the service. This only applies when type is set to LoadBalancer and externalTrafficPolicy is set to Local. If a value is specified, is in-range, and is not in use, it will be used. If not specified, a value will be automatically allocated. External systems (e.g. load-balancers) can use this port to determine if a given node holds endpoints for this service or not. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type). This field cannot be updated once set.", + "format": "int32", + "type": "integer" + }, + "internalTrafficPolicy": { + "description": "InternalTrafficPolicy describes how nodes distribute service traffic they receive on the ClusterIP. If set to \"Local\", the proxy will assume that pods only want to talk to endpoints of the service on the same node as the pod, dropping the traffic if there are no local endpoints. The default value, \"Cluster\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features).", + "type": "string" + }, + "ipFamilies": { + "description": "IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \"IPv4\" and \"IPv6\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \"headless\" services. This field will be wiped when updating a Service to type ExternalName.\n\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ipFamilyPolicy": { + "description": "IPFamilyPolicy represents the dual-stack-ness requested or required by this Service. If there is no value provided, then this field will be set to SingleStack. Services can be \"SingleStack\" (a single IP family), \"PreferDualStack\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \"RequireDualStack\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.", + "type": "string" + }, + "loadBalancerClass": { + "description": "loadBalancerClass is the class of the load balancer implementation this Service belongs to. If specified, the value of this field must be a label-style identifier, with an optional prefix, e.g. \"internal-vip\" or \"example.com/internal-vip\". Unprefixed names are reserved for end-users. This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load balancer implementation is used, today this is typically done through the cloud provider integration, but should apply for any default implementation. If set, it is assumed that a load balancer implementation is watching for Services with a matching class. Any default load balancer implementation (e.g. cloud providers) should ignore Services that set this field. This field can only be set when creating or updating a Service to type 'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.", + "type": "string" + }, + "loadBalancerIP": { + "description": "Only applies to Service Type: LoadBalancer. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. Deprecated: This field was under-specified and its meaning varies across implementations. Using it is non-portable and it may not support dual-stack. Users are encouraged to use implementation-specific annotations when available.", + "type": "string" + }, + "loadBalancerSourceRanges": { + "description": "If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ports": { + "description": "The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServicePort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "port", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "port", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "publishNotReadyAddresses": { + "description": "publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service should disregard any indications of ready/not-ready. The primary use case for setting this field is for a StatefulSet's Headless Service to propagate SRV DNS records for its Pods for the purpose of peer discovery. The Kubernetes controllers that generate Endpoints and EndpointSlice resources for Services interpret this to mean that all endpoints are considered \"ready\" even if the Pods themselves are not. Agents which consume only Kubernetes generated endpoints through the Endpoints or EndpointSlice resources can safely assume this behavior.", + "type": "boolean" + }, + "selector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "sessionAffinity": { + "description": "Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "type": "string" + }, + "sessionAffinityConfig": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig" + }, + "trafficDistribution": { + "description": "TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to \"PreferClose\", implementations should prioritize endpoints that are in the same zone.", + "type": "string" + }, + "type": { + "description": "type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. \"ExternalName\" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceStatus": { + "description": "ServiceStatus represents the current status of a service.", + "properties": { + "conditions": { + "description": "Current service state", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "loadBalancer": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SessionAffinityConfig": { + "description": "SessionAffinityConfig represents the configurations of session affinity.", + "properties": { + "clientIP": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClientIPConfig" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSPersistentVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Taint": { + "description": "The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint.", + "properties": { + "effect": { + "default": "", + "description": "Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "default": "", + "description": "Required. The taint key to be applied to a node.", + "type": "string" + }, + "timeAdded": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "value": { + "description": "The taint value corresponding to the taint key.", + "type": "string" + } + }, + "required": [ + "key", + "effect" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + }, + "azureDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + }, + "azureFile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + }, + "cephfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + }, + "cinder": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + }, + "csi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + }, + "emptyDir": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + }, + "ephemeral": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + }, + "fc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + }, + "flexVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + }, + "flocker": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + }, + "gcePersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + }, + "gitRepo": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + }, + "glusterfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + }, + "hostPath": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + }, + "image": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + }, + "iscsi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + }, + "persistentVolumeClaim": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + }, + "photonPersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + }, + "portworxVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + }, + "projected": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + }, + "quobyte": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + }, + "rbd": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + }, + "scaleIO": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + }, + "storageos": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + }, + "vsphereVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMountStatus": { + "description": "VolumeMountStatus shows status of volume mounts.", + "properties": { + "mountPath": { + "default": "", + "description": "MountPath corresponds to the original VolumeMount.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name corresponds to the name of the original VolumeMount.", + "type": "string" + }, + "readOnly": { + "description": "ReadOnly corresponds to the original VolumeMount.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly must be set to Disabled, Enabled, or unspecified (for non-readonly mounts). An IfPossible value in the original VolumeMount must be translated to Disabled or Enabled, depending on the mount result.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeNodeAffinity": { + "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.", + "properties": { + "required": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + }, + "podCertificate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + }, + "serviceAccountToken": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.api.policy.v1.Eviction": { + "description": "Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "deleteOptions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "Eviction", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/api/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCoreV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ] + } + }, + "/api/v1/componentstatuses": { + "get": { + "description": "list objects of kind ComponentStatus", + "operationId": "listCoreV1ComponentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatusList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/componentstatuses/{name}": { + "get": { + "description": "read the specified ComponentStatus", + "operationId": "readCoreV1ComponentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ComponentStatus" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ComponentStatus", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ComponentStatus", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/api/v1/configmaps": { + "get": { + "description": "list or watch objects of kind ConfigMap", + "operationId": "listCoreV1ConfigMapForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/endpoints": { + "get": { + "description": "list or watch objects of kind Endpoints", + "operationId": "listCoreV1EndpointsForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/events": { + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listCoreV1EventForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/limitranges": { + "get": { + "description": "list or watch objects of kind LimitRange", + "operationId": "listCoreV1LimitRangeForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/namespaces": { + "get": { + "description": "list or watch objects of kind Namespace", + "operationId": "listCoreV1Namespace", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NamespaceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Namespace", + "operationId": "createCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/bindings": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Binding", + "operationId": "createCoreV1NamespacedBinding", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Binding", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/configmaps": { + "delete": { + "description": "delete collection of ConfigMap", + "operationId": "deleteCoreV1CollectionNamespacedConfigMap", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ConfigMap", + "operationId": "listCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ConfigMap", + "operationId": "createCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/configmaps/{name}": { + "delete": { + "description": "delete a ConfigMap", + "operationId": "deleteCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "get": { + "description": "read the specified ConfigMap", + "operationId": "readCoreV1NamespacedConfigMap", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ConfigMap", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ConfigMap", + "operationId": "patchCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ConfigMap", + "operationId": "replaceCoreV1NamespacedConfigMap", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/endpoints": { + "delete": { + "description": "delete collection of Endpoints", + "operationId": "deleteCoreV1CollectionNamespacedEndpoints", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Endpoints", + "operationId": "listCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EndpointsList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create Endpoints", + "operationId": "createCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/endpoints/{name}": { + "delete": { + "description": "delete Endpoints", + "operationId": "deleteCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "get": { + "description": "read the specified Endpoints", + "operationId": "readCoreV1NamespacedEndpoints", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Endpoints", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Endpoints", + "operationId": "patchCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Endpoints", + "operationId": "replaceCoreV1NamespacedEndpoints", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Endpoints" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/events": { + "delete": { + "description": "delete collection of Event", + "operationId": "deleteCoreV1CollectionNamespacedEvent", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listCoreV1NamespacedEvent", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Event", + "operationId": "createCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/events/{name}": { + "delete": { + "description": "delete an Event", + "operationId": "deleteCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "read the specified Event", + "operationId": "readCoreV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Event", + "operationId": "patchCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Event", + "operationId": "replaceCoreV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/limitranges": { + "delete": { + "description": "delete collection of LimitRange", + "operationId": "deleteCoreV1CollectionNamespacedLimitRange", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind LimitRange", + "operationId": "listCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRangeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a LimitRange", + "operationId": "createCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/limitranges/{name}": { + "delete": { + "description": "delete a LimitRange", + "operationId": "deleteCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "get": { + "description": "read the specified LimitRange", + "operationId": "readCoreV1NamespacedLimitRange", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the LimitRange", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified LimitRange", + "operationId": "patchCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "put": { + "description": "replace the specified LimitRange", + "operationId": "replaceCoreV1NamespacedLimitRange", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LimitRange" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims": { + "delete": { + "description": "delete collection of PersistentVolumeClaim", + "operationId": "deleteCoreV1CollectionNamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PersistentVolumeClaim", + "operationId": "listCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PersistentVolumeClaim", + "operationId": "createCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}": { + "delete": { + "description": "delete a PersistentVolumeClaim", + "operationId": "deleteCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "get": { + "description": "read the specified PersistentVolumeClaim", + "operationId": "readCoreV1NamespacedPersistentVolumeClaim", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PersistentVolumeClaim", + "operationId": "patchCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PersistentVolumeClaim", + "operationId": "replaceCoreV1NamespacedPersistentVolumeClaim", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status": { + "get": { + "description": "read status of the specified PersistentVolumeClaim", + "operationId": "readCoreV1NamespacedPersistentVolumeClaimStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PersistentVolumeClaim", + "operationId": "patchCoreV1NamespacedPersistentVolumeClaimStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PersistentVolumeClaim", + "operationId": "replaceCoreV1NamespacedPersistentVolumeClaimStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods": { + "delete": { + "description": "delete collection of Pod", + "operationId": "deleteCoreV1CollectionNamespacedPod", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Pod", + "operationId": "listCoreV1NamespacedPod", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Pod", + "operationId": "createCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}": { + "delete": { + "description": "delete a Pod", + "operationId": "deleteCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "get": { + "description": "read the specified Pod", + "operationId": "readCoreV1NamespacedPod", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Pod", + "operationId": "patchCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Pod", + "operationId": "replaceCoreV1NamespacedPod", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/attach": { + "get": { + "description": "connect GET requests to attach of Pod", + "operationId": "connectCoreV1GetNamespacedPodAttach", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodAttachOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "The container in which to execute the command. Defaults to only container if there is only one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the PodAttachOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true.", + "in": "query", + "name": "stderr", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false.", + "in": "query", + "name": "stdin", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true.", + "in": "query", + "name": "stdout", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "TTY if true indicates that a tty will be allocated for the attach call. This is passed through the container runtime so the tty is allocated on the worker node by the container runtime. Defaults to false.", + "in": "query", + "name": "tty", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to attach of Pod", + "operationId": "connectCoreV1PostNamespacedPodAttach", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodAttachOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/binding": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Binding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create binding of a Pod", + "operationId": "createCoreV1NamespacedPodBinding", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Binding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Binding", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers": { + "get": { + "description": "read ephemeralcontainers of the specified Pod", + "operationId": "readCoreV1NamespacedPodEphemeralcontainers", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update ephemeralcontainers of the specified Pod", + "operationId": "patchCoreV1NamespacedPodEphemeralcontainers", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace ephemeralcontainers of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodEphemeralcontainers", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/eviction": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Eviction", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create eviction of a Pod", + "operationId": "createCoreV1NamespacedPodEviction", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.Eviction" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "Eviction", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/exec": { + "get": { + "description": "connect GET requests to exec of Pod", + "operationId": "connectCoreV1GetNamespacedPodExec", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodExecOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "Command is the remote command to execute. argv array. Not executed within a shell.", + "in": "query", + "name": "command", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Container in which to execute the command. Defaults to only container if there is only one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the PodExecOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard error stream of the pod for this call.", + "in": "query", + "name": "stderr", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard input stream of the pod for this call. Defaults to false.", + "in": "query", + "name": "stdin", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Redirect the standard output stream of the pod for this call.", + "in": "query", + "name": "stdout", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "TTY if true indicates that a tty will be allocated for the exec call. Defaults to false.", + "in": "query", + "name": "tty", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to exec of Pod", + "operationId": "connectCoreV1PostNamespacedPodExec", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodExecOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/log": { + "get": { + "description": "read log of the specified Pod", + "operationId": "readCoreV1NamespacedPodLog", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "type": "string" + } + }, + "application/json": { + "schema": { + "type": "string" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "type": "string" + } + }, + "application/yaml": { + "schema": { + "type": "string" + } + }, + "text/plain": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "The container for which to stream logs. Defaults to only container if there is one container in the pod.", + "in": "query", + "name": "container", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Follow the log stream of the pod. Defaults to false.", + "in": "query", + "name": "follow", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "insecureSkipTLSVerifyBackend indicates that the apiserver should not confirm the validity of the serving certificate of the backend it is connecting to. This will make the HTTPS connection between the apiserver and the backend insecure. This means the apiserver cannot verify the log data it is receiving came from the real kubelet. If the kubelet is configured to verify the apiserver's TLS credentials, it does not mean the connection to the real kubelet is vulnerable to a man in the middle attack (e.g. an attacker could not intercept the actual log data coming from the real kubelet).", + "in": "query", + "name": "insecureSkipTLSVerifyBackend", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "If set, the number of bytes to read from the server before terminating the log output. This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit.", + "in": "query", + "name": "limitBytes", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Return previous terminated container logs. Defaults to false.", + "in": "query", + "name": "previous", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A relative time in seconds before the current time from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified.", + "in": "query", + "name": "sinceSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Specify which container log stream to return to the client. Acceptable values are \"All\", \"Stdout\" and \"Stderr\". If not specified, \"All\" is used, and both stdout and stderr are returned interleaved. Note that when \"TailLines\" is specified, \"Stream\" can only be set to nil or \"All\".", + "in": "query", + "name": "stream", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation of the container or sinceSeconds or sinceTime. Note that when \"TailLines\" is specified, \"Stream\" can only be set to nil or \"All\".", + "in": "query", + "name": "tailLines", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false.", + "in": "query", + "name": "timestamps", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/namespaces/{namespace}/pods/{name}/portforward": { + "get": { + "description": "connect GET requests to portforward of Pod", + "operationId": "connectCoreV1GetNamespacedPodPortforward", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodPortForwardOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodPortForwardOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "List of ports to forward Required when using WebSockets", + "in": "query", + "name": "ports", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "post": { + "description": "connect POST requests to portforward of Pod", + "operationId": "connectCoreV1PostNamespacedPodPortforward", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodPortForwardOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Pod", + "operationId": "connectCoreV1DeleteNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Pod", + "operationId": "connectCoreV1GetNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Pod", + "operationId": "connectCoreV1HeadNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Pod", + "operationId": "connectCoreV1OptionsNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to pod.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Pod", + "operationId": "connectCoreV1PatchNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Pod", + "operationId": "connectCoreV1PostNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Pod", + "operationId": "connectCoreV1PutNamespacedPodProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Pod", + "operationId": "connectCoreV1DeleteNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Pod", + "operationId": "connectCoreV1GetNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Pod", + "operationId": "connectCoreV1HeadNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Pod", + "operationId": "connectCoreV1OptionsNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to pod.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Pod", + "operationId": "connectCoreV1PatchNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Pod", + "operationId": "connectCoreV1PostNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Pod", + "operationId": "connectCoreV1PutNamespacedPodProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/resize": { + "get": { + "description": "read resize of the specified Pod", + "operationId": "readCoreV1NamespacedPodResize", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update resize of the specified Pod", + "operationId": "patchCoreV1NamespacedPodResize", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace resize of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodResize", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/pods/{name}/status": { + "get": { + "description": "read status of the specified Pod", + "operationId": "readCoreV1NamespacedPodStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Pod", + "operationId": "patchCoreV1NamespacedPodStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Pod", + "operationId": "replaceCoreV1NamespacedPodStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Pod" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/podtemplates": { + "delete": { + "description": "delete collection of PodTemplate", + "operationId": "deleteCoreV1CollectionNamespacedPodTemplate", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PodTemplate", + "operationId": "listCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PodTemplate", + "operationId": "createCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/podtemplates/{name}": { + "delete": { + "description": "delete a PodTemplate", + "operationId": "deleteCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "get": { + "description": "read the specified PodTemplate", + "operationId": "readCoreV1NamespacedPodTemplate", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the PodTemplate", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PodTemplate", + "operationId": "patchCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PodTemplate", + "operationId": "replaceCoreV1NamespacedPodTemplate", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplate" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers": { + "delete": { + "description": "delete collection of ReplicationController", + "operationId": "deleteCoreV1CollectionNamespacedReplicationController", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ReplicationController", + "operationId": "listCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ReplicationController", + "operationId": "createCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}": { + "delete": { + "description": "delete a ReplicationController", + "operationId": "deleteCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "get": { + "description": "read the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationController", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationController", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale": { + "get": { + "description": "read scale of the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationControllerScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationControllerScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationControllerScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status": { + "get": { + "description": "read status of the specified ReplicationController", + "operationId": "readCoreV1NamespacedReplicationControllerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ReplicationController", + "operationId": "patchCoreV1NamespacedReplicationControllerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ReplicationController", + "operationId": "replaceCoreV1NamespacedReplicationControllerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationController" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas": { + "delete": { + "description": "delete collection of ResourceQuota", + "operationId": "deleteCoreV1CollectionNamespacedResourceQuota", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ResourceQuota", + "operationId": "listCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ResourceQuota", + "operationId": "createCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas/{name}": { + "delete": { + "description": "delete a ResourceQuota", + "operationId": "deleteCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "get": { + "description": "read the specified ResourceQuota", + "operationId": "readCoreV1NamespacedResourceQuota", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ResourceQuota", + "operationId": "patchCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ResourceQuota", + "operationId": "replaceCoreV1NamespacedResourceQuota", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status": { + "get": { + "description": "read status of the specified ResourceQuota", + "operationId": "readCoreV1NamespacedResourceQuotaStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ResourceQuota", + "operationId": "patchCoreV1NamespacedResourceQuotaStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ResourceQuota", + "operationId": "replaceCoreV1NamespacedResourceQuotaStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuota" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/secrets": { + "delete": { + "description": "delete collection of Secret", + "operationId": "deleteCoreV1CollectionNamespacedSecret", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Secret", + "operationId": "listCoreV1NamespacedSecret", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Secret", + "operationId": "createCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/secrets/{name}": { + "delete": { + "description": "delete a Secret", + "operationId": "deleteCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "get": { + "description": "read the specified Secret", + "operationId": "readCoreV1NamespacedSecret", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Secret", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Secret", + "operationId": "patchCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Secret", + "operationId": "replaceCoreV1NamespacedSecret", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Secret" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts": { + "delete": { + "description": "delete collection of ServiceAccount", + "operationId": "deleteCoreV1CollectionNamespacedServiceAccount", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ServiceAccount", + "operationId": "listCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ServiceAccount", + "operationId": "createCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts/{name}": { + "delete": { + "description": "delete a ServiceAccount", + "operationId": "deleteCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "get": { + "description": "read the specified ServiceAccount", + "operationId": "readCoreV1NamespacedServiceAccount", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ServiceAccount", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ServiceAccount", + "operationId": "patchCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ServiceAccount", + "operationId": "replaceCoreV1NamespacedServiceAccount", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccount" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the TokenRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create token of a ServiceAccount", + "operationId": "createCoreV1NamespacedServiceAccountToken", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.authentication.v1.TokenRequest" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "authentication.k8s.io", + "kind": "TokenRequest", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services": { + "delete": { + "description": "delete collection of Service", + "operationId": "deleteCoreV1CollectionNamespacedService", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Service", + "operationId": "listCoreV1NamespacedService", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Service", + "operationId": "createCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}": { + "delete": { + "description": "delete a Service", + "operationId": "deleteCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "get": { + "description": "read the specified Service", + "operationId": "readCoreV1NamespacedService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Service", + "operationId": "patchCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Service", + "operationId": "replaceCoreV1NamespacedService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Service", + "operationId": "connectCoreV1DeleteNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Service", + "operationId": "connectCoreV1GetNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Service", + "operationId": "connectCoreV1HeadNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Service", + "operationId": "connectCoreV1OptionsNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Service", + "operationId": "connectCoreV1PatchNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Service", + "operationId": "connectCoreV1PostNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Service", + "operationId": "connectCoreV1PutNamespacedServiceProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Service", + "operationId": "connectCoreV1DeleteNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Service", + "operationId": "connectCoreV1GetNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Service", + "operationId": "connectCoreV1HeadNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Service", + "operationId": "connectCoreV1OptionsNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Service", + "operationId": "connectCoreV1PatchNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Service", + "operationId": "connectCoreV1PostNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Service", + "operationId": "connectCoreV1PutNamespacedServiceProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{namespace}/services/{name}/status": { + "get": { + "description": "read status of the specified Service", + "operationId": "readCoreV1NamespacedServiceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Service", + "operationId": "patchCoreV1NamespacedServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Service", + "operationId": "replaceCoreV1NamespacedServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Service" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}": { + "delete": { + "description": "delete a Namespace", + "operationId": "deleteCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "get": { + "description": "read the specified Namespace", + "operationId": "readCoreV1Namespace", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Namespace", + "operationId": "patchCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Namespace", + "operationId": "replaceCoreV1Namespace", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}/finalize": { + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "put": { + "description": "replace finalize of the specified Namespace", + "operationId": "replaceCoreV1NamespaceFinalize", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/namespaces/{name}/status": { + "get": { + "description": "read status of the specified Namespace", + "operationId": "readCoreV1NamespaceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Namespace", + "operationId": "patchCoreV1NamespaceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Namespace", + "operationId": "replaceCoreV1NamespaceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Namespace" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + } + }, + "/api/v1/nodes": { + "delete": { + "description": "delete collection of Node", + "operationId": "deleteCoreV1CollectionNode", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Node", + "operationId": "listCoreV1Node", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Node", + "operationId": "createCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}": { + "delete": { + "description": "delete a Node", + "operationId": "deleteCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "get": { + "description": "read the specified Node", + "operationId": "readCoreV1Node", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Node", + "operationId": "patchCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Node", + "operationId": "replaceCoreV1Node", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/proxy": { + "delete": { + "description": "connect DELETE requests to proxy of Node", + "operationId": "connectCoreV1DeleteNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Node", + "operationId": "connectCoreV1GetNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Node", + "operationId": "connectCoreV1HeadNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Node", + "operationId": "connectCoreV1OptionsNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the NodeProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to node.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Node", + "operationId": "connectCoreV1PatchNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Node", + "operationId": "connectCoreV1PostNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Node", + "operationId": "connectCoreV1PutNodeProxy", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/proxy/{path}": { + "delete": { + "description": "connect DELETE requests to proxy of Node", + "operationId": "connectCoreV1DeleteNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "get": { + "description": "connect GET requests to proxy of Node", + "operationId": "connectCoreV1GetNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "head": { + "description": "connect HEAD requests to proxy of Node", + "operationId": "connectCoreV1HeadNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "options": { + "description": "connect OPTIONS requests to proxy of Node", + "operationId": "connectCoreV1OptionsNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the NodeProxyOptions", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "path to the resource", + "in": "path", + "name": "path", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Path is the URL path to use for the current proxy request to node.", + "in": "query", + "name": "path", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "connect PATCH requests to proxy of Node", + "operationId": "connectCoreV1PatchNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "post": { + "description": "connect POST requests to proxy of Node", + "operationId": "connectCoreV1PostNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + }, + "put": { + "description": "connect PUT requests to proxy of Node", + "operationId": "connectCoreV1PutNodeProxyWithPath", + "responses": { + "200": { + "content": { + "*/*": { + "schema": { + "type": "string" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "connect", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "NodeProxyOptions", + "version": "v1" + } + } + }, + "/api/v1/nodes/{name}/status": { + "get": { + "description": "read status of the specified Node", + "operationId": "readCoreV1NodeStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Node", + "operationId": "patchCoreV1NodeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Node", + "operationId": "replaceCoreV1NodeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Node" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumeclaims": { + "get": { + "description": "list or watch objects of kind PersistentVolumeClaim", + "operationId": "listCoreV1PersistentVolumeClaimForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/persistentvolumes": { + "delete": { + "description": "delete collection of PersistentVolume", + "operationId": "deleteCoreV1CollectionPersistentVolume", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PersistentVolume", + "operationId": "listCoreV1PersistentVolume", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PersistentVolume", + "operationId": "createCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumes/{name}": { + "delete": { + "description": "delete a PersistentVolume", + "operationId": "deleteCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "get": { + "description": "read the specified PersistentVolume", + "operationId": "readCoreV1PersistentVolume", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PersistentVolume", + "operationId": "patchCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PersistentVolume", + "operationId": "replaceCoreV1PersistentVolume", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/persistentvolumes/{name}/status": { + "get": { + "description": "read status of the specified PersistentVolume", + "operationId": "readCoreV1PersistentVolumeStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PersistentVolume", + "operationId": "patchCoreV1PersistentVolumeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PersistentVolume", + "operationId": "replaceCoreV1PersistentVolumeStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolume" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + } + }, + "/api/v1/pods": { + "get": { + "description": "list or watch objects of kind Pod", + "operationId": "listCoreV1PodForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/podtemplates": { + "get": { + "description": "list or watch objects of kind PodTemplate", + "operationId": "listCoreV1PodTemplateForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/replicationcontrollers": { + "get": { + "description": "list or watch objects of kind ReplicationController", + "operationId": "listCoreV1ReplicationControllerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/resourcequotas": { + "get": { + "description": "list or watch objects of kind ResourceQuota", + "operationId": "listCoreV1ResourceQuotaForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/secrets": { + "get": { + "description": "list or watch objects of kind Secret", + "operationId": "listCoreV1SecretForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/serviceaccounts": { + "get": { + "description": "list or watch objects of kind ServiceAccount", + "operationId": "listCoreV1ServiceAccountForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/services": { + "get": { + "description": "list or watch objects of kind Service", + "operationId": "listCoreV1ServiceForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/configmaps": { + "get": { + "description": "watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ConfigMapListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/endpoints": { + "get": { + "description": "watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1EndpointsListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1EventListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/limitranges": { + "get": { + "description": "watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1LimitRangeListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces": { + "get": { + "description": "watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespaceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/configmaps": { + "get": { + "description": "watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedConfigMapList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/configmaps/{name}": { + "get": { + "description": "watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedConfigMap", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ConfigMap", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ConfigMap", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/endpoints": { + "get": { + "description": "watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedEndpointsList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/endpoints/{name}": { + "get": { + "description": "watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedEndpoints", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Endpoints", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Endpoints", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedEventList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/events/{name}": { + "get": { + "description": "watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Event", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/limitranges": { + "get": { + "description": "watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedLimitRangeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/limitranges/{name}": { + "get": { + "description": "watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedLimitRange", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "LimitRange", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the LimitRange", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims": { + "get": { + "description": "watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPersistentVolumeClaimList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}": { + "get": { + "description": "watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPersistentVolumeClaim", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PersistentVolumeClaim", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/pods": { + "get": { + "description": "watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPodList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/pods/{name}": { + "get": { + "description": "watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPod", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Pod", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/podtemplates": { + "get": { + "description": "watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedPodTemplateList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/podtemplates/{name}": { + "get": { + "description": "watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedPodTemplate", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PodTemplate", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/replicationcontrollers": { + "get": { + "description": "watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedReplicationControllerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}": { + "get": { + "description": "watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedReplicationController", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ReplicationController", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/resourcequotas": { + "get": { + "description": "watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedResourceQuotaList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}": { + "get": { + "description": "watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedResourceQuota", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ResourceQuota", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/secrets": { + "get": { + "description": "watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedSecretList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/secrets/{name}": { + "get": { + "description": "watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedSecret", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Secret", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/serviceaccounts": { + "get": { + "description": "watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedServiceAccountList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}": { + "get": { + "description": "watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedServiceAccount", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ServiceAccount", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/services": { + "get": { + "description": "watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NamespacedServiceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{namespace}/services/{name}": { + "get": { + "description": "watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1NamespacedService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Service", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/namespaces/{name}": { + "get": { + "description": "watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1Namespace", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Namespace", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Namespace", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/nodes": { + "get": { + "description": "watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1NodeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/nodes/{name}": { + "get": { + "description": "watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1Node", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Node", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Node", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumeclaims": { + "get": { + "description": "watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PersistentVolumeClaimListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumes": { + "get": { + "description": "watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PersistentVolumeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/persistentvolumes/{name}": { + "get": { + "description": "watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoreV1PersistentVolume", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PersistentVolume", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PersistentVolume", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/pods": { + "get": { + "description": "watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PodListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Pod", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/podtemplates": { + "get": { + "description": "watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1PodTemplateListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "PodTemplate", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/replicationcontrollers": { + "get": { + "description": "watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ReplicationControllerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ReplicationController", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/resourcequotas": { + "get": { + "description": "watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ResourceQuotaListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ResourceQuota", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/secrets": { + "get": { + "description": "watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1SecretListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Secret", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/serviceaccounts": { + "get": { + "description": "watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ServiceAccountListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "ServiceAccount", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/api/v1/watch/services": { + "get": { + "description": "watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoreV1ServiceListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "core_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "", + "kind": "Service", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1.json b/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1.json new file mode 100644 index 00000000..8f7af3a5 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1.json @@ -0,0 +1,3648 @@ +{ + "components": { + "schemas": { + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition": { + "description": "CustomResourceColumnDefinition specifies a column for server side printing.", + "properties": { + "description": { + "description": "description is a human readable description of this column.", + "type": "string" + }, + "format": { + "description": "format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.", + "type": "string" + }, + "jsonPath": { + "default": "", + "description": "jsonPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is a human readable name for the column.", + "type": "string" + }, + "priority": { + "description": "priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0.", + "format": "int32", + "type": "integer" + }, + "type": { + "default": "", + "description": "type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.", + "type": "string" + } + }, + "required": [ + "name", + "type", + "jsonPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion": { + "description": "CustomResourceConversion describes how to convert different versions of a CR.", + "properties": { + "strategy": { + "default": "", + "description": "strategy specifies how custom resources are converted between versions. Allowed values are: - `\"None\"`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `\"Webhook\"`: API Server will call to an external webhook to do the conversion. Additional information\n is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set.", + "type": "string" + }, + "webhook": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion" + } + ], + "description": "webhook describes how to call the conversion webhook. Required when `strategy` is set to `\"Webhook\"`." + } + }, + "required": [ + "strategy" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition": { + "description": "CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec" + } + ], + "default": {}, + "description": "spec describes how the user wants the resources to appear" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus" + } + ], + "default": {}, + "description": "status indicates the actual state of the CustomResourceDefinition" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + ] + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition": { + "description": "CustomResourceDefinitionCondition contains details for the current condition of this pod.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime last time the condition transitioned from one status to another." + }, + "message": { + "description": "message is a human-readable message indicating details about last transition.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "description": "reason is a unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "status is the status of the condition. Can be True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type is the type of the condition. Types include Established, NamesAccepted and Terminating.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList": { + "description": "CustomResourceDefinitionList is a list of CustomResourceDefinition objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items list individual CustomResourceDefinition objects", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinitionList", + "version": "v1" + } + ] + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames": { + "description": "CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition", + "properties": { + "categories": { + "description": "categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "kind": { + "default": "", + "description": "kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls.", + "type": "string" + }, + "listKind": { + "description": "listKind is the serialized kind of the list for this resource. Defaults to \"`kind`List\".", + "type": "string" + }, + "plural": { + "default": "", + "description": "plural is the plural name of the resource to serve. The custom resources are served under `/apis///.../`. Must match the name of the CustomResourceDefinition (in the form `.`). Must be all lowercase.", + "type": "string" + }, + "shortNames": { + "description": "shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get `. It must be all lowercase.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singular": { + "description": "singular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`.", + "type": "string" + } + }, + "required": [ + "plural", + "kind" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec": { + "description": "CustomResourceDefinitionSpec describes how a user wants their resource to appear", + "properties": { + "conversion": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion" + } + ], + "description": "conversion defines conversion settings for the CRD." + }, + "group": { + "default": "", + "description": "group is the API group of the defined custom resource. The custom resources are served under `/apis//...`. Must match the name of the CustomResourceDefinition (in the form `.`).", + "type": "string" + }, + "names": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames" + } + ], + "default": {}, + "description": "names specify the resource and kind names for the custom resource." + }, + "preserveUnknownFields": { + "description": "preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#field-pruning for details.", + "type": "boolean" + }, + "scope": { + "default": "", + "description": "scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`.", + "type": "string" + }, + "versions": { + "description": "versions is the list of all API versions of the defined custom resource. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "group", + "names", + "scope", + "versions" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus": { + "description": "CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition", + "properties": { + "acceptedNames": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames" + } + ], + "default": {}, + "description": "acceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec." + }, + "conditions": { + "description": "conditions indicate state for particular aspects of a CustomResourceDefinition", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map" + }, + "observedGeneration": { + "description": "The generation observed by the CRD controller.", + "format": "int64", + "type": "integer" + }, + "storedVersions": { + "description": "storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion": { + "description": "CustomResourceDefinitionVersion describes a version for CRD.", + "properties": { + "additionalPrinterColumns": { + "description": "additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "deprecated": { + "description": "deprecated indicates this version of the custom resource API is deprecated. When set to true, API requests to this version receive a warning header in the server response. Defaults to false.", + "type": "boolean" + }, + "deprecationWarning": { + "description": "deprecationWarning overrides the default warning returned to API clients. May only be set when `deprecated` is true. The default warning indicates this version is deprecated and recommends use of the newest served version of equal or greater stability, if one exists.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the version name, e.g. “v1”, “v2beta1”, etc. The custom resources are served under this version at `/apis///...` if `served` is true.", + "type": "string" + }, + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation" + } + ], + "description": "schema describes the schema used for validation, pruning, and defaulting of this version of the custom resource." + }, + "selectableFields": { + "description": "selectableFields specifies paths to fields that may be used as field selectors. A maximum of 8 selectable fields are allowed. See https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "served": { + "default": false, + "description": "served is a flag enabling/disabling this version from being served via REST APIs", + "type": "boolean" + }, + "storage": { + "default": false, + "description": "storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true.", + "type": "boolean" + }, + "subresources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources" + } + ], + "description": "subresources specify what subresources this version of the defined custom resource have." + } + }, + "required": [ + "name", + "served", + "storage" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale": { + "description": "CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources.", + "properties": { + "labelSelectorPath": { + "description": "labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string.", + "type": "string" + }, + "specReplicasPath": { + "default": "", + "description": "specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET.", + "type": "string" + }, + "statusReplicasPath": { + "default": "", + "description": "statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0.", + "type": "string" + } + }, + "required": [ + "specReplicasPath", + "statusReplicasPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus": { + "description": "CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza", + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources": { + "description": "CustomResourceSubresources defines the status and scale subresources for CustomResources.", + "properties": { + "scale": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale" + } + ], + "description": "scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus" + } + ], + "description": "status indicates the custom resource should serve a `/status` subresource. When enabled: 1. requests to the custom resource primary endpoint ignore changes to the `status` stanza of the object. 2. requests to the custom resource `/status` subresource ignore changes to anything other than the `status` stanza of the object." + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation": { + "description": "CustomResourceValidation is a list of validation methods for CustomResources.", + "properties": { + "openAPIV3Schema": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "description": "openAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning." + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation": { + "description": "ExternalDocumentation allows referencing an external resource for extended documentation.", + "properties": { + "description": { + "type": "string" + }, + "url": { + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON": { + "description": "JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps": { + "description": "JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/).", + "properties": { + "$ref": { + "type": "string" + }, + "$schema": { + "type": "string" + }, + "additionalItems": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool" + }, + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool" + }, + "allOf": { + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "anyOf": { + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "default": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + } + ], + "description": "default is a default value for undefined object fields. Defaulting is a beta feature under the CustomResourceDefaulting feature gate. Defaulting requires spec.preserveUnknownFields to be false." + }, + "definitions": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "dependencies": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray" + }, + "type": "object" + }, + "description": { + "type": "string" + }, + "enum": { + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "example": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + }, + "exclusiveMaximum": { + "type": "boolean" + }, + "exclusiveMinimum": { + "type": "boolean" + }, + "externalDocs": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation" + }, + "format": { + "description": "format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated:\n\n- bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like \"0321751043\" or \"978-0321751041\" - isbn10: an ISBN10 number string like \"0321751043\" - isbn13: an ISBN13 number string like \"978-0321751041\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\\\d{3})\\\\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\\\d{3}[- ]?\\\\d{2}[- ]?\\\\d{4}$ - hexcolor: an hexadecimal color code like \"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like \"rgb(255,255,2559\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \"2006-01-02\" as defined by full-date in RFC3339 - duration: a duration string like \"22 ns\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \"2014-12-15T19:30:20.000Z\" as defined by date-time in RFC3339.", + "type": "string" + }, + "id": { + "type": "string" + }, + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray" + }, + "maxItems": { + "format": "int64", + "type": "integer" + }, + "maxLength": { + "format": "int64", + "type": "integer" + }, + "maxProperties": { + "format": "int64", + "type": "integer" + }, + "maximum": { + "format": "double", + "type": "number" + }, + "minItems": { + "format": "int64", + "type": "integer" + }, + "minLength": { + "format": "int64", + "type": "integer" + }, + "minProperties": { + "format": "int64", + "type": "integer" + }, + "minimum": { + "format": "double", + "type": "number" + }, + "multipleOf": { + "format": "double", + "type": "number" + }, + "not": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + }, + "nullable": { + "type": "boolean" + }, + "oneOf": { + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pattern": { + "type": "string" + }, + "patternProperties": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "properties": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "required": { + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "title": { + "type": "string" + }, + "type": { + "type": "string" + }, + "uniqueItems": { + "type": "boolean" + }, + "x-kubernetes-embedded-resource": { + "description": "x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata).", + "type": "boolean" + }, + "x-kubernetes-int-or-string": { + "description": "x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns:\n\n1) anyOf:\n - type: integer\n - type: string\n2) allOf:\n - anyOf:\n - type: integer\n - type: string\n - ... zero or more", + "type": "boolean" + }, + "x-kubernetes-list-map-keys": { + "description": "x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map.\n\nThis tag MUST only be used on lists that have the \"x-kubernetes-list-type\" extension set to \"map\". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported).\n\nThe properties specified must either be required or have a default value, to ensure those properties are present for all list items.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "x-kubernetes-list-type": { + "description": "x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values:\n\n1) `atomic`: the list is treated as a single entity, like a scalar.\n Atomic lists will be entirely replaced when updated. This extension\n may be used on any type of list (struct, scalar, ...).\n2) `set`:\n Sets are lists that must not have multiple items with the same value. Each\n value must be a scalar, an object with x-kubernetes-map-type `atomic` or an\n array with x-kubernetes-list-type `atomic`.\n3) `map`:\n These lists are like maps in that their elements have a non-index key\n used to identify them. Order is preserved upon merge. The map tag\n must only be used on a list with elements of type object.\nDefaults to atomic for arrays.", + "type": "string" + }, + "x-kubernetes-map-type": { + "description": "x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values:\n\n1) `granular`:\n These maps are actual maps (key-value pairs) and each fields are independent\n from each other (they can each be manipulated by separate actors). This is\n the default behaviour for all maps.\n2) `atomic`: the list is treated as a single entity, like a scalar.\n Atomic maps will be entirely replaced when updated.", + "type": "string" + }, + "x-kubernetes-preserve-unknown-fields": { + "description": "x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden.", + "type": "boolean" + }, + "x-kubernetes-validations": { + "description": "x-kubernetes-validations describes a list of validation rules written in the CEL expression language.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "rule" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "rule", + "x-kubernetes-patch-strategy": "merge" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray": { + "description": "JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool": { + "description": "JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray": { + "description": "JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField": { + "description": "SelectableField specifies the JSON path of a field that may be used with field selectors.", + "properties": { + "jsonPath": { + "default": "", + "description": "jsonPath is a simple JSON path which is evaluated against each custom resource to produce a field selector value. Only JSON paths without the array notation are allowed. Must point to a field of type string, boolean or integer. Types with enum values and strings with formats are allowed. If jsonPath refers to absent field in a resource, the jsonPath evaluates to an empty string. Must not point to metdata fields. Required.", + "type": "string" + } + }, + "required": [ + "jsonPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference": { + "description": "ServiceReference holds a reference to Service.legacy.k8s.io", + "properties": { + "name": { + "default": "", + "description": "name is the name of the service. Required", + "type": "string" + }, + "namespace": { + "default": "", + "description": "namespace is the namespace of the service. Required", + "type": "string" + }, + "path": { + "description": "path is an optional URL path at which the webhook will be contacted.", + "type": "string" + }, + "port": { + "description": "port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "namespace", + "name" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule": { + "description": "ValidationRule describes a validation rule written in the CEL expression language.", + "properties": { + "fieldPath": { + "description": "fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']`", + "type": "string" + }, + "message": { + "description": "Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\"", + "type": "string" + }, + "messageExpression": { + "description": "MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a rule, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the rule; the only difference is the return type. Example: \"x must be less than max (\"+string(self.max)+\")\"", + "type": "string" + }, + "optionalOldSelf": { + "description": "optionalOldSelf is used to opt a transition rule into evaluation even when the object is first created, or if the old object is missing the value.\n\nWhen enabled `oldSelf` will be a CEL optional whose value will be `None` if there is no old value, or when the object is initially created.\n\nYou may check for presence of oldSelf using `oldSelf.hasValue()` and unwrap it after checking using `oldSelf.value()`. Check the CEL documentation for Optional types for more information: https://pkg.go.dev/github.com/google/cel-go/cel#OptionalTypes\n\nMay not be set unless `oldSelf` is used in `rule`.", + "type": "boolean" + }, + "reason": { + "description": "reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule. The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule. The currently supported reasons are: \"FieldValueInvalid\", \"FieldValueForbidden\", \"FieldValueRequired\", \"FieldValueDuplicate\". If not set, default to use \"FieldValueInvalid\". All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid.", + "type": "string" + }, + "rule": { + "default": "", + "description": "Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {\"rule\": \"self.status.actual <= self.spec.maxDesired\"}\n\nIf the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {\"rule\": \"self.components['Widget'].priority < 10\"} - Rule scoped to a list of integers: {\"rule\": \"self.values.all(value, value >= 0 && value < 100)\"} - Rule scoped to a string value: {\"rule\": \"self.startsWith('kube')\"}\n\nThe `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.\n\nUnknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an \"unknown type\". An \"unknown type\" is recursively defined as:\n - A schema with no type and x-kubernetes-preserve-unknown-fields set to true\n - An array where the items schema is of an \"unknown type\"\n - An object where the additionalProperties schema is of an \"unknown type\"\n\nOnly property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are:\n\t \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\",\n\t \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\".\nExamples:\n - Rule accessing a property named \"namespace\": {\"rule\": \"self.__namespace__ > 0\"}\n - Rule accessing a property named \"x-prop\": {\"rule\": \"self.x__dash__prop > 0\"}\n - Rule accessing a property named \"redact__d\": {\"rule\": \"self.redact__underscores__d > 0\"}\n\nEquality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type:\n - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and\n non-intersecting elements in `Y` are appended, retaining their partial order.\n - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values\n are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with\n non-intersecting keys are appended, retaining their partial order.\n\nIf `rule` makes use of the `oldSelf` variable it is implicitly a `transition rule`.\n\nBy default, the `oldSelf` variable is the same type as `self`. When `optionalOldSelf` is true, the `oldSelf` variable is a CEL optional\n variable whose value() is the same type as `self`.\nSee the documentation for the `optionalOldSelf` field for details.\n\nTransition rules by default are applied only on UPDATE requests and are skipped if an old value could not be found. You can opt a transition rule into unconditional evaluation by setting `optionalOldSelf` to true.", + "type": "string" + } + }, + "required": [ + "rule" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig": { + "description": "WebhookClientConfig contains the information to make a TLS connection with the webhook.", + "properties": { + "caBundle": { + "description": "caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used.", + "format": "byte", + "type": "string" + }, + "service": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference" + } + ], + "description": "service is a reference to the service for this webhook. Either service or url must be specified.\n\nIf the webhook is running within the cluster, then you should use `service`." + }, + "url": { + "description": "url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified.\n\nThe `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.\n\nPlease note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.\n\nThe scheme must be \"https\"; the URL must begin with \"https://\".\n\nA path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.\n\nAttempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion": { + "description": "WebhookConversion describes how to call a conversion webhook", + "properties": { + "clientConfig": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig" + } + ], + "description": "clientConfig is the instructions for how to call the webhook if strategy is `Webhook`." + }, + "conversionReviewVersions": { + "description": "conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "conversionReviewVersions" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apiextensions.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getApiextensionsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ] + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions": { + "delete": { + "description": "delete collection of CustomResourceDefinition", + "operationId": "deleteApiextensionsV1CollectionCustomResourceDefinition", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CustomResourceDefinition", + "operationId": "listApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CustomResourceDefinition", + "operationId": "createApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}": { + "delete": { + "description": "delete a CustomResourceDefinition", + "operationId": "deleteApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "get": { + "description": "read the specified CustomResourceDefinition", + "operationId": "readApiextensionsV1CustomResourceDefinition", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CustomResourceDefinition", + "operationId": "patchApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CustomResourceDefinition", + "operationId": "replaceApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status": { + "get": { + "description": "read status of the specified CustomResourceDefinition", + "operationId": "readApiextensionsV1CustomResourceDefinitionStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CustomResourceDefinition", + "operationId": "patchApiextensionsV1CustomResourceDefinitionStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CustomResourceDefinition", + "operationId": "replaceApiextensionsV1CustomResourceDefinitionStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions": { + "get": { + "description": "watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchApiextensionsV1CustomResourceDefinitionList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}": { + "get": { + "description": "watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchApiextensionsV1CustomResourceDefinition", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1_patched.json new file mode 100644 index 00000000..daed84a5 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apiextensions.k8s.io_v1_patched.json @@ -0,0 +1,3482 @@ +{ + "components": { + "schemas": { + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition": { + "description": "CustomResourceColumnDefinition specifies a column for server side printing.", + "properties": { + "description": { + "description": "description is a human readable description of this column.", + "type": "string" + }, + "format": { + "description": "format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.", + "type": "string" + }, + "jsonPath": { + "default": "", + "description": "jsonPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is a human readable name for the column.", + "type": "string" + }, + "priority": { + "description": "priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0.", + "format": "int32", + "type": "integer" + }, + "type": { + "default": "", + "description": "type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.", + "type": "string" + } + }, + "required": [ + "name", + "type", + "jsonPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion": { + "description": "CustomResourceConversion describes how to convert different versions of a CR.", + "properties": { + "strategy": { + "default": "", + "description": "strategy specifies how custom resources are converted between versions. Allowed values are: - `\"None\"`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `\"Webhook\"`: API Server will call to an external webhook to do the conversion. Additional information\n is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set.", + "type": "string" + }, + "webhook": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion" + } + }, + "required": [ + "strategy" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition": { + "description": "CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + ] + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition": { + "description": "CustomResourceDefinitionCondition contains details for the current condition of this pod.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message is a human-readable message indicating details about last transition.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "description": "reason is a unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "status is the status of the condition. Can be True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type is the type of the condition. Types include Established, NamesAccepted and Terminating.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList": { + "description": "CustomResourceDefinitionList is a list of CustomResourceDefinition objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items list individual CustomResourceDefinition objects", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinitionList", + "version": "v1" + } + ] + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames": { + "description": "CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition", + "properties": { + "categories": { + "description": "categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "kind": { + "default": "", + "description": "kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls.", + "type": "string" + }, + "listKind": { + "description": "listKind is the serialized kind of the list for this resource. Defaults to \"`kind`List\".", + "type": "string" + }, + "plural": { + "default": "", + "description": "plural is the plural name of the resource to serve. The custom resources are served under `/apis///.../`. Must match the name of the CustomResourceDefinition (in the form `.`). Must be all lowercase.", + "type": "string" + }, + "shortNames": { + "description": "shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get `. It must be all lowercase.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singular": { + "description": "singular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`.", + "type": "string" + } + }, + "required": [ + "plural", + "kind" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec": { + "description": "CustomResourceDefinitionSpec describes how a user wants their resource to appear", + "properties": { + "conversion": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion" + }, + "group": { + "default": "", + "description": "group is the API group of the defined custom resource. The custom resources are served under `/apis//...`. Must match the name of the CustomResourceDefinition (in the form `.`).", + "type": "string" + }, + "names": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames" + }, + "preserveUnknownFields": { + "description": "preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#field-pruning for details.", + "type": "boolean" + }, + "scope": { + "default": "", + "description": "scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`.", + "type": "string" + }, + "versions": { + "description": "versions is the list of all API versions of the defined custom resource. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "group", + "names", + "scope", + "versions" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus": { + "description": "CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition", + "properties": { + "acceptedNames": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames" + }, + "conditions": { + "description": "conditions indicate state for particular aspects of a CustomResourceDefinition", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "nullable": true + }, + "observedGeneration": { + "description": "The generation observed by the CRD controller.", + "format": "int64", + "type": "integer" + }, + "storedVersions": { + "description": "storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion": { + "description": "CustomResourceDefinitionVersion describes a version for CRD.", + "properties": { + "additionalPrinterColumns": { + "description": "additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used.", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "deprecated": { + "description": "deprecated indicates this version of the custom resource API is deprecated. When set to true, API requests to this version receive a warning header in the server response. Defaults to false.", + "type": "boolean" + }, + "deprecationWarning": { + "description": "deprecationWarning overrides the default warning returned to API clients. May only be set when `deprecated` is true. The default warning indicates this version is deprecated and recommends use of the newest served version of equal or greater stability, if one exists.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the version name, e.g. “v1”, “v2beta1”, etc. The custom resources are served under this version at `/apis///...` if `served` is true.", + "type": "string" + }, + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation" + }, + "selectableFields": { + "description": "selectableFields specifies paths to fields that may be used as field selectors. A maximum of 8 selectable fields are allowed. See https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "served": { + "default": false, + "description": "served is a flag enabling/disabling this version from being served via REST APIs", + "type": "boolean" + }, + "storage": { + "default": false, + "description": "storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true.", + "type": "boolean" + }, + "subresources": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources" + } + }, + "required": [ + "name", + "served", + "storage" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale": { + "description": "CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources.", + "properties": { + "labelSelectorPath": { + "description": "labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string.", + "type": "string" + }, + "specReplicasPath": { + "default": "", + "description": "specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET.", + "type": "string" + }, + "statusReplicasPath": { + "default": "", + "description": "statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0.", + "type": "string" + } + }, + "required": [ + "specReplicasPath", + "statusReplicasPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus": { + "description": "CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza", + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources": { + "description": "CustomResourceSubresources defines the status and scale subresources for CustomResources.", + "properties": { + "scale": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation": { + "description": "CustomResourceValidation is a list of validation methods for CustomResources.", + "properties": { + "openAPIV3Schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation": { + "description": "ExternalDocumentation allows referencing an external resource for extended documentation.", + "properties": { + "description": { + "type": "string" + }, + "url": { + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON": { + "description": "JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps": { + "description": "JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/).", + "properties": { + "$ref": { + "type": "string" + }, + "$schema": { + "type": "string" + }, + "additionalItems": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool" + }, + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool" + }, + "allOf": { + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "anyOf": { + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "default": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + }, + "definitions": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "dependencies": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray" + }, + "type": "object" + }, + "description": { + "type": "string" + }, + "enum": { + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "example": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON" + }, + "exclusiveMaximum": { + "type": "boolean" + }, + "exclusiveMinimum": { + "type": "boolean" + }, + "externalDocs": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation" + }, + "format": { + "description": "format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated:\n\n- bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like \"0321751043\" or \"978-0321751041\" - isbn10: an ISBN10 number string like \"0321751043\" - isbn13: an ISBN13 number string like \"978-0321751041\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\\\d{3})\\\\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\\\d{3}[- ]?\\\\d{2}[- ]?\\\\d{4}$ - hexcolor: an hexadecimal color code like \"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like \"rgb(255,255,2559\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \"2006-01-02\" as defined by full-date in RFC3339 - duration: a duration string like \"22 ns\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \"2014-12-15T19:30:20.000Z\" as defined by date-time in RFC3339.", + "type": "string" + }, + "id": { + "type": "string" + }, + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray" + }, + "maxItems": { + "format": "int64", + "type": "integer" + }, + "maxLength": { + "format": "int64", + "type": "integer" + }, + "maxProperties": { + "format": "int64", + "type": "integer" + }, + "maximum": { + "format": "double", + "type": "number" + }, + "minItems": { + "format": "int64", + "type": "integer" + }, + "minLength": { + "format": "int64", + "type": "integer" + }, + "minProperties": { + "format": "int64", + "type": "integer" + }, + "minimum": { + "format": "double", + "type": "number" + }, + "multipleOf": { + "format": "double", + "type": "number" + }, + "not": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + }, + "nullable": { + "type": "boolean" + }, + "oneOf": { + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pattern": { + "type": "string" + }, + "patternProperties": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "properties": { + "additionalProperties": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps" + } + ], + "default": {} + }, + "type": "object" + }, + "required": { + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "title": { + "type": "string" + }, + "type": { + "type": "string" + }, + "uniqueItems": { + "type": "boolean" + }, + "x-kubernetes-embedded-resource": { + "description": "x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata).", + "type": "boolean" + }, + "x-kubernetes-int-or-string": { + "description": "x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns:\n\n1) anyOf:\n - type: integer\n - type: string\n2) allOf:\n - anyOf:\n - type: integer\n - type: string\n - ... zero or more", + "type": "boolean" + }, + "x-kubernetes-list-map-keys": { + "description": "x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map.\n\nThis tag MUST only be used on lists that have the \"x-kubernetes-list-type\" extension set to \"map\". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported).\n\nThe properties specified must either be required or have a default value, to ensure those properties are present for all list items.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "x-kubernetes-list-type": { + "description": "x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values:\n\n1) `atomic`: the list is treated as a single entity, like a scalar.\n Atomic lists will be entirely replaced when updated. This extension\n may be used on any type of list (struct, scalar, ...).\n2) `set`:\n Sets are lists that must not have multiple items with the same value. Each\n value must be a scalar, an object with x-kubernetes-map-type `atomic` or an\n array with x-kubernetes-list-type `atomic`.\n3) `map`:\n These lists are like maps in that their elements have a non-index key\n used to identify them. Order is preserved upon merge. The map tag\n must only be used on a list with elements of type object.\nDefaults to atomic for arrays.", + "type": "string" + }, + "x-kubernetes-map-type": { + "description": "x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values:\n\n1) `granular`:\n These maps are actual maps (key-value pairs) and each fields are independent\n from each other (they can each be manipulated by separate actors). This is\n the default behaviour for all maps.\n2) `atomic`: the list is treated as a single entity, like a scalar.\n Atomic maps will be entirely replaced when updated.", + "type": "string" + }, + "x-kubernetes-preserve-unknown-fields": { + "description": "x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden.", + "type": "boolean" + }, + "x-kubernetes-validations": { + "description": "x-kubernetes-validations describes a list of validation rules written in the CEL expression language.", + "items": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "rule" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "rule", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray": { + "description": "JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool": { + "description": "JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray": { + "description": "JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array." + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField": { + "description": "SelectableField specifies the JSON path of a field that may be used with field selectors.", + "properties": { + "jsonPath": { + "default": "", + "description": "jsonPath is a simple JSON path which is evaluated against each custom resource to produce a field selector value. Only JSON paths without the array notation are allowed. Must point to a field of type string, boolean or integer. Types with enum values and strings with formats are allowed. If jsonPath refers to absent field in a resource, the jsonPath evaluates to an empty string. Must not point to metdata fields. Required.", + "type": "string" + } + }, + "required": [ + "jsonPath" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference": { + "description": "ServiceReference holds a reference to Service.legacy.k8s.io", + "properties": { + "name": { + "default": "", + "description": "name is the name of the service. Required", + "type": "string" + }, + "namespace": { + "default": "", + "description": "namespace is the namespace of the service. Required", + "type": "string" + }, + "path": { + "description": "path is an optional URL path at which the webhook will be contacted.", + "type": "string" + }, + "port": { + "description": "port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "namespace", + "name" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule": { + "description": "ValidationRule describes a validation rule written in the CEL expression language.", + "properties": { + "fieldPath": { + "description": "fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']`", + "type": "string" + }, + "message": { + "description": "Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is \"failed rule: {Rule}\". e.g. \"must be a URL with the host matching spec.host\"", + "type": "string" + }, + "messageExpression": { + "description": "MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a rule, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the rule; the only difference is the return type. Example: \"x must be less than max (\"+string(self.max)+\")\"", + "type": "string" + }, + "optionalOldSelf": { + "description": "optionalOldSelf is used to opt a transition rule into evaluation even when the object is first created, or if the old object is missing the value.\n\nWhen enabled `oldSelf` will be a CEL optional whose value will be `None` if there is no old value, or when the object is initially created.\n\nYou may check for presence of oldSelf using `oldSelf.hasValue()` and unwrap it after checking using `oldSelf.value()`. Check the CEL documentation for Optional types for more information: https://pkg.go.dev/github.com/google/cel-go/cel#OptionalTypes\n\nMay not be set unless `oldSelf` is used in `rule`.", + "type": "boolean" + }, + "reason": { + "description": "reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule. The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule. The currently supported reasons are: \"FieldValueInvalid\", \"FieldValueForbidden\", \"FieldValueRequired\", \"FieldValueDuplicate\". If not set, default to use \"FieldValueInvalid\". All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid.", + "type": "string" + }, + "rule": { + "default": "", + "description": "Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {\"rule\": \"self.status.actual <= self.spec.maxDesired\"}\n\nIf the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {\"rule\": \"self.components['Widget'].priority < 10\"} - Rule scoped to a list of integers: {\"rule\": \"self.values.all(value, value >= 0 && value < 100)\"} - Rule scoped to a string value: {\"rule\": \"self.startsWith('kube')\"}\n\nThe `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.\n\nUnknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an \"unknown type\". An \"unknown type\" is recursively defined as:\n - A schema with no type and x-kubernetes-preserve-unknown-fields set to true\n - An array where the items schema is of an \"unknown type\"\n - An object where the additionalProperties schema is of an \"unknown type\"\n\nOnly property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are:\n\t \"true\", \"false\", \"null\", \"in\", \"as\", \"break\", \"const\", \"continue\", \"else\", \"for\", \"function\", \"if\",\n\t \"import\", \"let\", \"loop\", \"package\", \"namespace\", \"return\".\nExamples:\n - Rule accessing a property named \"namespace\": {\"rule\": \"self.__namespace__ > 0\"}\n - Rule accessing a property named \"x-prop\": {\"rule\": \"self.x__dash__prop > 0\"}\n - Rule accessing a property named \"redact__d\": {\"rule\": \"self.redact__underscores__d > 0\"}\n\nEquality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type:\n - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and\n non-intersecting elements in `Y` are appended, retaining their partial order.\n - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values\n are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with\n non-intersecting keys are appended, retaining their partial order.\n\nIf `rule` makes use of the `oldSelf` variable it is implicitly a `transition rule`.\n\nBy default, the `oldSelf` variable is the same type as `self`. When `optionalOldSelf` is true, the `oldSelf` variable is a CEL optional\n variable whose value() is the same type as `self`.\nSee the documentation for the `optionalOldSelf` field for details.\n\nTransition rules by default are applied only on UPDATE requests and are skipped if an old value could not be found. You can opt a transition rule into unconditional evaluation by setting `optionalOldSelf` to true.", + "type": "string" + } + }, + "required": [ + "rule" + ], + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig": { + "description": "WebhookClientConfig contains the information to make a TLS connection with the webhook.", + "properties": { + "caBundle": { + "description": "caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used.", + "format": "byte", + "type": "string" + }, + "service": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference" + }, + "url": { + "description": "url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified.\n\nThe `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.\n\nPlease note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.\n\nThe scheme must be \"https\"; the URL must begin with \"https://\".\n\nA path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.\n\nAttempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion": { + "description": "WebhookConversion describes how to call a conversion webhook", + "properties": { + "clientConfig": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig" + }, + "conversionReviewVersions": { + "description": "conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "conversionReviewVersions" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apiextensions.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getApiextensionsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ] + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions": { + "delete": { + "description": "delete collection of CustomResourceDefinition", + "operationId": "deleteApiextensionsV1CollectionCustomResourceDefinition", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CustomResourceDefinition", + "operationId": "listApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CustomResourceDefinition", + "operationId": "createApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}": { + "delete": { + "description": "delete a CustomResourceDefinition", + "operationId": "deleteApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "get": { + "description": "read the specified CustomResourceDefinition", + "operationId": "readApiextensionsV1CustomResourceDefinition", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CustomResourceDefinition", + "operationId": "patchApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CustomResourceDefinition", + "operationId": "replaceApiextensionsV1CustomResourceDefinition", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status": { + "get": { + "description": "read status of the specified CustomResourceDefinition", + "operationId": "readApiextensionsV1CustomResourceDefinitionStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CustomResourceDefinition", + "operationId": "patchApiextensionsV1CustomResourceDefinitionStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CustomResourceDefinition", + "operationId": "replaceApiextensionsV1CustomResourceDefinitionStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + } + }, + "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions": { + "get": { + "description": "watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchApiextensionsV1CustomResourceDefinitionList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}": { + "get": { + "description": "watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchApiextensionsV1CustomResourceDefinition", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiextensions_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apiextensions.k8s.io", + "kind": "CustomResourceDefinition", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CustomResourceDefinition", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1.json b/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1.json new file mode 100644 index 00000000..2eb04c98 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1.json @@ -0,0 +1,2991 @@ +{ + "components": { + "schemas": { + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService": { + "description": "APIService represents a server for a particular GroupVersion. Name must be \"version.group\".", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec" + } + ], + "default": {}, + "description": "Spec contains information for locating and communicating with a server" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus" + } + ], + "default": {}, + "description": "Status contains derived information about an API server" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + ] + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition": { + "description": "APIServiceCondition describes the state of an APIService at a particular point", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList": { + "description": "APIServiceList is a list of APIService objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of APIService", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiregistration.k8s.io", + "kind": "APIServiceList", + "version": "v1" + } + ] + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec": { + "description": "APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.", + "properties": { + "caBundle": { + "description": "CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used.", + "format": "byte", + "type": "string", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "Group is the API group name this server hosts", + "type": "string" + }, + "groupPriorityMinimum": { + "default": 0, + "description": "GroupPriorityMinimum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMinimum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s", + "format": "int32", + "type": "integer" + }, + "insecureSkipTLSVerify": { + "description": "InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead.", + "type": "boolean" + }, + "service": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference" + } + ], + "description": "Service is a reference to the service for this API server. It must communicate on port 443. If the Service is nil, that means the handling for the API groupversion is handled locally on this server. The call will simply delegate to the normal handler chain to be fulfilled." + }, + "version": { + "description": "Version is the API version this server hosts. For example, \"v1\"", + "type": "string" + }, + "versionPriority": { + "default": 0, + "description": "VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "groupPriorityMinimum", + "versionPriority" + ], + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus": { + "description": "APIServiceStatus contains derived information about an API server", + "properties": { + "conditions": { + "description": "Current service state of apiService.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + } + }, + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference": { + "description": "ServiceReference holds a reference to Service.legacy.k8s.io", + "properties": { + "name": { + "description": "Name is the name of the service", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of the service", + "type": "string" + }, + "port": { + "description": "If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apiregistration.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getApiregistrationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ] + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices": { + "delete": { + "description": "delete collection of APIService", + "operationId": "deleteApiregistrationV1CollectionAPIService", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind APIService", + "operationId": "listApiregistrationV1APIService", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an APIService", + "operationId": "createApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices/{name}": { + "delete": { + "description": "delete an APIService", + "operationId": "deleteApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "get": { + "description": "read the specified APIService", + "operationId": "readApiregistrationV1APIService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified APIService", + "operationId": "patchApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "put": { + "description": "replace the specified APIService", + "operationId": "replaceApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status": { + "get": { + "description": "read status of the specified APIService", + "operationId": "readApiregistrationV1APIServiceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified APIService", + "operationId": "patchApiregistrationV1APIServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified APIService", + "operationId": "replaceApiregistrationV1APIServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/watch/apiservices": { + "get": { + "description": "watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchApiregistrationV1APIServiceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}": { + "get": { + "description": "watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchApiregistrationV1APIService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1_patched.json new file mode 100644 index 00000000..9f4d8921 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apiregistration.k8s.io_v1_patched.json @@ -0,0 +1,2903 @@ +{ + "components": { + "schemas": { + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService": { + "description": "APIService represents a server for a particular GroupVersion. Name must be \"version.group\".", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + ] + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition": { + "description": "APIServiceCondition describes the state of an APIService at a particular point", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "Unique, one-word, CamelCase reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList": { + "description": "APIServiceList is a list of APIService objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of APIService", + "items": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apiregistration.k8s.io", + "kind": "APIServiceList", + "version": "v1" + } + ] + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec": { + "description": "APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.", + "properties": { + "caBundle": { + "description": "CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used.", + "format": "byte", + "type": "string", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "Group is the API group name this server hosts", + "type": "string" + }, + "groupPriorityMinimum": { + "default": 0, + "description": "GroupPriorityMinimum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMinimum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s", + "format": "int32", + "type": "integer" + }, + "insecureSkipTLSVerify": { + "description": "InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead.", + "type": "boolean" + }, + "service": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference" + }, + "version": { + "description": "Version is the API version this server hosts. For example, \"v1\"", + "type": "string" + }, + "versionPriority": { + "default": 0, + "description": "VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "groupPriorityMinimum", + "versionPriority" + ], + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus": { + "description": "APIServiceStatus contains derived information about an API server", + "properties": { + "conditions": { + "description": "Current service state of apiService.", + "items": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference": { + "description": "ServiceReference holds a reference to Service.legacy.k8s.io", + "properties": { + "name": { + "description": "Name is the name of the service", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of the service", + "type": "string" + }, + "port": { + "description": "If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apiregistration.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getApiregistrationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ] + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices": { + "delete": { + "description": "delete collection of APIService", + "operationId": "deleteApiregistrationV1CollectionAPIService", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind APIService", + "operationId": "listApiregistrationV1APIService", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an APIService", + "operationId": "createApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices/{name}": { + "delete": { + "description": "delete an APIService", + "operationId": "deleteApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "get": { + "description": "read the specified APIService", + "operationId": "readApiregistrationV1APIService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified APIService", + "operationId": "patchApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "put": { + "description": "replace the specified APIService", + "operationId": "replaceApiregistrationV1APIService", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status": { + "get": { + "description": "read status of the specified APIService", + "operationId": "readApiregistrationV1APIServiceStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified APIService", + "operationId": "patchApiregistrationV1APIServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified APIService", + "operationId": "replaceApiregistrationV1APIServiceStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + } + }, + "/apis/apiregistration.k8s.io/v1/watch/apiservices": { + "get": { + "description": "watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchApiregistrationV1APIServiceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}": { + "get": { + "description": "watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchApiregistrationV1APIService", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apiregistration_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apiregistration.k8s.io", + "kind": "APIService", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the APIService", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apps_v1.json b/gen/openapi_v1/specs/apis_apps_v1.json new file mode 100644 index 00000000..15df0b37 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apps_v1.json @@ -0,0 +1,17090 @@ +{ + "components": { + "schemas": { + "io.k8s.api.apps.v1.ControllerRevision": { + "description": "ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Data is the serialized representation of the state." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "revision": { + "default": 0, + "description": "Revision indicates the revision of the state represented by Data.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "revision" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ControllerRevisionList": { + "description": "ControllerRevisionList is a resource containing a list of ControllerRevision objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of ControllerRevisions", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ControllerRevisionList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSet": { + "description": "DaemonSet represents the configuration of a daemon set.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec" + } + ], + "default": {}, + "description": "The desired behavior of this daemon set. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus" + } + ], + "default": {}, + "description": "The current status of this daemon set. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSetCondition": { + "description": "DaemonSetCondition describes the state of a DaemonSet at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of DaemonSet condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetList": { + "description": "DaemonSetList is a collection of daemon sets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "A list of daemon sets.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DaemonSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSetSpec": { + "description": "DaemonSetSpec is the specification of a daemon set.", + "properties": { + "minReadySeconds": { + "description": "The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready).", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over pods that are managed by the daemon set. Must match in order to be controlled. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "An object that describes the pod that will be created. The DaemonSet will create exactly one copy of this pod on every node that matches the template's node selector (or on every node if no node selector is specified). The only allowed template.spec.restartPolicy value is \"Always\". More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template" + }, + "updateStrategy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy" + } + ], + "default": {}, + "description": "An update strategy to replace existing DaemonSet pods with new pods." + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetStatus": { + "description": "DaemonSetStatus represents the current status of a daemon set.", + "properties": { + "collisionCount": { + "description": "Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a DaemonSet's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentNumberScheduled": { + "default": 0, + "description": "The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "desiredNumberScheduled": { + "default": 0, + "description": "The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "numberAvailable": { + "description": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds)", + "format": "int32", + "type": "integer" + }, + "numberMisscheduled": { + "default": 0, + "description": "The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "numberReady": { + "default": 0, + "description": "numberReady is the number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "numberUnavailable": { + "description": "The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds)", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "The most recent generation observed by the daemon set controller.", + "format": "int64", + "type": "integer" + }, + "updatedNumberScheduled": { + "description": "The total number of nodes that are running updated daemon pod", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "currentNumberScheduled", + "numberMisscheduled", + "desiredNumberScheduled", + "numberReady" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetUpdateStrategy": { + "description": "DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet.", + "properties": { + "rollingUpdate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet" + } + ], + "description": "Rolling update config params. Present only if type = \"RollingUpdate\"." + }, + "type": { + "description": "Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.Deployment": { + "description": "Deployment enables declarative updates for Pods and ReplicaSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the Deployment." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentStatus" + } + ], + "default": {}, + "description": "Most recently observed status of the Deployment." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DeploymentCondition": { + "description": "DeploymentCondition describes the state of a deployment at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "lastUpdateTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "The last time this condition was updated." + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of deployment condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentList": { + "description": "DeploymentList is a list of Deployments.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of Deployments.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DeploymentList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DeploymentSpec": { + "description": "DeploymentSpec is the specification of the desired behavior of the Deployment.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "paused": { + "description": "Indicates that the deployment is paused.", + "type": "boolean" + }, + "progressDeadlineSeconds": { + "description": "The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Label selector for pods. Existing ReplicaSets whose pods are selected by this will be the ones affected by this deployment. It must match the pod template's labels." + }, + "strategy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy" + } + ], + "default": {}, + "description": "The deployment strategy to use to replace existing pods with new ones.", + "x-kubernetes-patch-strategy": "retainKeys" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "Template describes the pods that will be created. The only allowed template.spec.restartPolicy value is \"Always\"." + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentStatus": { + "description": "DeploymentStatus is the most recently observed status of the Deployment.", + "properties": { + "availableReplicas": { + "description": "Total number of available non-terminating pods (ready for at least minReadySeconds) targeted by this deployment.", + "format": "int32", + "type": "integer" + }, + "collisionCount": { + "description": "Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a deployment's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "observedGeneration": { + "description": "The generation observed by the deployment controller.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "Total number of non-terminating pods targeted by this Deployment with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Total number of non-terminating pods targeted by this deployment (their labels match the selector).", + "format": "int32", + "type": "integer" + }, + "terminatingReplicas": { + "description": "Total number of terminating pods targeted by this deployment. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\n\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).", + "format": "int32", + "type": "integer" + }, + "unavailableReplicas": { + "description": "Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.", + "format": "int32", + "type": "integer" + }, + "updatedReplicas": { + "description": "Total number of non-terminating pods targeted by this deployment that have the desired template spec.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentStrategy": { + "description": "DeploymentStrategy describes how to replace existing pods with new ones.", + "properties": { + "rollingUpdate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment" + } + ], + "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate." + }, + "type": { + "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSet": { + "description": "ReplicaSet ensures that a specified number of pod replicas are running at any given time.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "If the Labels of a ReplicaSet are empty, they are defaulted to be the same as the Pod(s) that the ReplicaSet manages. Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec" + } + ], + "default": {}, + "description": "Spec defines the specification of the desired behavior of the ReplicaSet. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus" + } + ], + "default": {}, + "description": "Status is the most recently observed status of the ReplicaSet. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ReplicaSetCondition": { + "description": "ReplicaSetCondition describes the state of a replica set at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "The last time the condition transitioned from one status to another." + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of replica set condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSetList": { + "description": "ReplicaSetList is a collection of ReplicaSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ReplicaSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ReplicaSetSpec": { + "description": "ReplicaSetSpec is the specification of a ReplicaSet.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Replicas is the number of desired pods. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "format": "int32", + "type": "integer" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Selector is a label query over pods that should match the replica count. Label keys and values that must match in order to be controlled by this replica set. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "Template is the object that describes the pod that will be created if insufficient replicas are detected. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/#pod-template" + } + }, + "required": [ + "selector" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSetStatus": { + "description": "ReplicaSetStatus represents the current status of a ReplicaSet.", + "properties": { + "availableReplicas": { + "description": "The number of available non-terminating pods (ready for at least minReadySeconds) for this replica set.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a replica set's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "fullyLabeledReplicas": { + "description": "The number of non-terminating pods that have labels matching the labels of the pod template of the replicaset.", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "ObservedGeneration reflects the generation of the most recently observed ReplicaSet.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "The number of non-terminating pods targeted by this ReplicaSet with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "Replicas is the most recently observed number of non-terminating pods. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "format": "int32", + "type": "integer" + }, + "terminatingReplicas": { + "description": "The number of terminating pods for this replica set. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\n\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateDaemonSet": { + "description": "Spec to control the desired behavior of daemon set rolling update.", + "properties": { + "maxSurge": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediately created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption." + }, + "maxUnavailable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update." + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateDeployment": { + "description": "Spec to control the desired behavior of rolling update.", + "properties": { + "maxSurge": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods." + }, + "maxUnavailable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding down. This can not be 0 if MaxSurge is 0. Defaults to 25%. Example: when this is set to 30%, the old ReplicaSet can be scaled down to 70% of desired pods immediately when the rolling update starts. Once new pods are ready, old ReplicaSet can be scaled down further, followed by scaling up the new ReplicaSet, ensuring that the total number of pods available at all times during the update is at least 70% of desired pods." + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy": { + "description": "RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.", + "properties": { + "maxUnavailable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding up. This can not be 0. Defaults to 1. This field is beta-level and is enabled by default. The field applies to all pods in the range 0 to Replicas-1. That means if there is any unavailable pod in the range 0 to Replicas-1, it will be counted towards MaxUnavailable. This setting might not be effective for the OrderedReady podManagementPolicy. That policy ensures pods are created and become ready one at a time." + }, + "partition": { + "description": "Partition indicates the ordinal at which the StatefulSet should be partitioned for updates. During a rolling update, all pods from ordinal Replicas-1 to Partition are updated. All pods from ordinal Partition-1 to 0 remain untouched. This is helpful in being able to do a canary based deployment. The default value is 0.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSet": { + "description": "StatefulSet represents a set of pods with consistent identities. Identities are defined as:\n - Network: A single stable DNS and hostname.\n - Storage: As many VolumeClaims as requested.\n\nThe StatefulSet guarantees that a given network identity will always map to the same storage identity.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec" + } + ], + "default": {}, + "description": "Spec defines the desired identities of pods in this set." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus" + } + ], + "default": {}, + "description": "Status is the current status of Pods in this StatefulSet. This data may be out of date by some window of time." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.StatefulSetCondition": { + "description": "StatefulSetCondition describes the state of a statefulset at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transitioned from one status to another." + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of statefulset condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetList": { + "description": "StatefulSetList is a collection of StatefulSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of stateful sets.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "StatefulSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.StatefulSetOrdinals": { + "description": "StatefulSetOrdinals describes the policy used for replica ordinal assignment in this StatefulSet.", + "properties": { + "start": { + "default": 0, + "description": "start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range:\n [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas).\nIf unset, defaults to 0. Replica indices will be in the range:\n [0, .spec.replicas).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy": { + "description": "StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.", + "properties": { + "whenDeleted": { + "description": "WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.", + "type": "string" + }, + "whenScaled": { + "description": "WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetSpec": { + "description": "A StatefulSetSpec is the specification of a StatefulSet.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "ordinals": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals" + } + ], + "description": "ordinals controls the numbering of replica indices in a StatefulSet. The default ordinals behavior assigns a \"0\" index to the first replica and increments the index by one for each additional replica requested." + }, + "persistentVolumeClaimRetentionPolicy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy" + } + ], + "description": "persistentVolumeClaimRetentionPolicy describes the lifecycle of persistent volume claims created from volumeClaimTemplates. By default, all persistent volume claims are created as needed and retained until manually deleted. This policy allows the lifecycle to be altered, for example by deleting persistent volume claims when their stateful set is deleted, or when their pod is scaled down." + }, + "podManagementPolicy": { + "description": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", + "type": "string" + }, + "replicas": { + "description": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors" + }, + "serviceName": { + "default": "", + "description": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", + "type": "string" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet. Each pod will be named with the format -. For example, a pod in a StatefulSet named \"web\" with index number \"3\" would be named \"web-3\". The only allowed template.spec.restartPolicy value is \"Always\"." + }, + "updateStrategy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy" + } + ], + "default": {}, + "description": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template." + }, + "volumeClaimTemplates": { + "description": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetStatus": { + "description": "StatefulSetStatus represents the current state of a StatefulSet.", + "properties": { + "availableReplicas": { + "default": 0, + "description": "Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset.", + "format": "int32", + "type": "integer" + }, + "collisionCount": { + "description": "collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a statefulset's current state.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentReplicas": { + "description": "currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.", + "format": "int32", + "type": "integer" + }, + "currentRevision": { + "description": "currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "readyReplicas is the number of pods created for this StatefulSet with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "replicas is the number of Pods created by the StatefulSet controller.", + "format": "int32", + "type": "integer" + }, + "updateRevision": { + "description": "updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)", + "type": "string" + }, + "updatedReplicas": { + "description": "updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetUpdateStrategy": { + "description": "StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy.", + "properties": { + "rollingUpdate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy" + } + ], + "description": "RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType." + }, + "type": { + "description": "Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.Scale": { + "description": "Scale represents a scaling request for a resource.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec" + } + ], + "default": {}, + "description": "spec defines the behavior of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus" + } + ], + "default": {}, + "description": "status is the current status of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. Read-only." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.ScaleSpec": { + "description": "ScaleSpec describes the attributes of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the desired number of instances for the scaled object.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.ScaleStatus": { + "description": "ScaleStatus represents the current status of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the actual number of observed instances of the scaled object.", + "format": "int32", + "type": "integer" + }, + "selector": { + "description": "selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/", + "type": "string" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + } + ], + "description": "Describes node affinity scheduling rules for the pod." + }, + "podAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + } + ], + "description": "Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s))." + }, + "podAntiAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + ], + "description": "Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s))." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed." + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is optional: points to a secret object containing parameters used to connect to OpenStack." + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Select all ClusterTrustBundles that match this label selector. Only has effect if signerName is set. Mutually-exclusive with name. If unset, interpreted as \"match nothing\". If set but empty, interpreted as \"match everything\"." + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Actions that the management system should take in response to container lifecycle events. Cannot be updated." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/" + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported." + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported." + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + } + ], + "description": "The ConfigMap to select from" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + ], + "description": "The Secret to select from" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + ], + "description": "Source for the environment variable's value. Cannot be used if value is not empty." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + } + ], + "description": "Selects a key of a ConfigMap." + }, + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs." + }, + "fileKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + } + ], + "description": "FileKeyRef selects a key of the env file. Requires the EnvFiles feature gate to be enabled." + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported." + }, + "secretKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + ], + "description": "Selects a key of a secret in the pod's namespace" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Lifecycle is not allowed for ephemeral containers." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext." + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + ], + "description": "Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts." + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is the CHAP Secret for iSCSI target and initiator authentication" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "preStop": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "sleep": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + } + ], + "description": "Sleep represents a duration that the container should sleep." + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for backward compatibility. There is no validation of this field and lifecycle hooks will fail at runtime when it is specified." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ModifyVolumeStatus": { + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation", + "properties": { + "status": { + "default": "", + "description": "status is the status of the ControllerModifyVolume operation. It can be in any of following states:\n - Pending\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\n the specified VolumeAttributesClass not existing.\n - InProgress\n InProgress indicates that the volume is being modified.\n - Infeasible\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\n\t resolve the error, a valid VolumeAttributesClass needs to be specified.\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.", + "type": "string" + }, + "targetVolumeAttributesClassName": { + "description": "targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled", + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + ], + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeClaim": { + "description": "PersistentVolumeClaim is a user's request for and claim to a persistent volume", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + ], + "default": {}, + "description": "spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus" + } + ], + "default": {}, + "description": "status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimCondition": { + "description": "PersistentVolumeClaimCondition contains details about state of pvc", + "properties": { + "lastProbeTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastProbeTime is the time we probed the condition." + }, + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the time the condition transitioned from one status to another." + }, + "message": { + "description": "message is the human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"Resizing\" that means the underlying persistent volume is being resized.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "dataSource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + } + ], + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." + }, + "dataSourceRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + } + ], + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + } + ], + "default": {}, + "description": "resources represents the minimum resources the volume should have. Users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "selector is a label query over volumes to consider for binding." + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimStatus": { + "description": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "properties": { + "accessModes": { + "description": "accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "allocatedResourceStatuses": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nClaimResourceStatus can be in any of following states:\n\t- ControllerResizeInProgress:\n\t\tState set when resize controller starts resizing the volume in control-plane.\n\t- ControllerResizeFailed:\n\t\tState set when resize has failed in resize controller with a terminal error.\n\t- NodeResizePending:\n\t\tState set when resize controller has finished resizing the volume but further resizing of\n\t\tvolume is needed on the node.\n\t- NodeResizeInProgress:\n\t\tState set when kubelet starts resizing the volume.\n\t- NodeResizeFailed:\n\t\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\n\t\tNodeResizeFailed.\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\n\t- pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeFailed\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizePending\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeFailed\"\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\n\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object", + "x-kubernetes-map-type": "granular" + }, + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\n\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity represents the actual resources of the underlying volume.", + "type": "object" + }, + "conditions": { + "description": "conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentVolumeAttributesClassName": { + "description": "currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim", + "type": "string" + }, + "modifyVolumeStatus": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus" + } + ], + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation. When this is unset, there is no ModifyVolume operation being attempted." + }, + "phase": { + "description": "phase represents the current phase of PersistentVolumeClaim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + ], + "default": {}, + "description": "The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here." + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "namespaceSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces." + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + } + ], + "description": "If specified, the pod's scheduling constraints" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "dnsConfig": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + } + ], + "description": "Specifies the DNS parameters of a pod. Parameters specified here will be merged to the generated DNS configuration based on DNSPolicy." + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge" + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + } + ], + "description": "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.\n\nIf the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions\n\nIf the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.hostUsers - spec.resources - spec.securityContext.appArmorProfile - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.securityContext.supplementalGroupsPolicy - spec.containers[*].securityContext.appArmorProfile - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "description": "Resources is the total amount of CPU and Memory resources required by all containers in the pod. It supports specifying Requests and Limits for \"cpu\", \"memory\" and \"hugepages-\" resource names only. ResourceClaims are not supported.\n\nThis field enables fine-grained control over resource allocation for the entire pod, allowing resource sharing among containers in a pod.\n\nThis is an alpha field and requires enabling the PodLevelResources feature gate." + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + } + ], + "description": "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field." + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge" + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "workloadRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + ], + "description": "WorkloadRef provides a reference to the Workload object that this Pod belongs to. This field is used by the scheduler to identify the PodGroup and apply the correct group scheduling policies. The Workload object referenced by this field may not exist at the time the Pod is created. This field is immutable, but a Workload object with the same name may be recreated with different policies. Doing this during pod scheduling may result in the placement not conforming to the expected policies." + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {}, + "description": "A node selector term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + } + ], + "description": "GRPC specifies a GRPC HealthCheckRequest." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "TCPSocket specifies a connection to a TCP port." + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "Specifies the output format of the exposed resources, defaults to \"1\"" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map" + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail." + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by this container. If set, this profile overrides the pod's appArmorProfile. Note that this field cannot be set when spec.os.name is windows." + }, + "capabilities": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + } + ], + "description": "The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows." + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows." + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted." + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + } + ], + "description": "awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore" + }, + "azureDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + } + ], + "description": "azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver." + }, + "azureFile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + } + ], + "description": "azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver." + }, + "cephfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + } + ], + "description": "cephFS represents a Ceph FS mount on the host that shares a pod's lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported." + }, + "cinder": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + } + ], + "description": "cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: https://examples.k8s.io/mysql-cinder-pd/README.md" + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + } + ], + "description": "configMap represents a configMap that should populate this volume" + }, + "csi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + } + ], + "description": "csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers." + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + } + ], + "description": "downwardAPI represents downward API about the pod that should populate this volume" + }, + "emptyDir": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + } + ], + "description": "emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + }, + "ephemeral": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + } + ], + "description": "ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time." + }, + "fc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + } + ], + "description": "fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod." + }, + "flexVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + } + ], + "description": "flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead." + }, + "flocker": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + } + ], + "description": "flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported." + }, + "gcePersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + } + ], + "description": "gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk" + }, + "gitRepo": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + } + ], + "description": "gitRepo represents a git repository at a particular revision. Deprecated: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container." + }, + "glusterfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + } + ], + "description": "glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported." + }, + "hostPath": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + } + ], + "description": "hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath" + }, + "image": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + } + ], + "description": "image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet's host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided:\n\n- Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.\n\nThe volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type." + }, + "iscsi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + } + ], + "description": "iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes/#iscsi" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + } + ], + "description": "nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs" + }, + "persistentVolumeClaim": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + } + ], + "description": "persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + }, + "photonPersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + } + ], + "description": "photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported." + }, + "portworxVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + } + ], + "description": "portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver when the CSIMigrationPortworx feature-gate is on." + }, + "projected": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + } + ], + "description": "projected items for all in one resources secrets, configmaps, and downward API" + }, + "quobyte": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + } + ], + "description": "quobyte represents a Quobyte mount on the host that shares a pod's lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported." + }, + "rbd": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + } + ], + "description": "rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported." + }, + "scaleIO": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + } + ], + "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + } + ], + "description": "secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret" + }, + "storageos": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + } + ], + "description": "storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported." + }, + "vsphereVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + ], + "description": "vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + } + ], + "description": "ClusterTrustBundle allows a pod to access the `.spec.trustBundle` field of ClusterTrustBundle objects in an auto-updating file.\n\nAlpha, gated by the ClusterTrustBundleProjection feature gate.\n\nClusterTrustBundle objects can either be selected by name, or by the combination of signer name and a label selector.\n\nKubelet performs aggressive normalization of the PEM contents written into the pod filesystem. Esoteric PEM features such as inter-block comments and block headers are stripped. Certificates are deduplicated. The ordering of certificates within the file is arbitrary, and Kubelet may change the order over time." + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + } + ], + "description": "configMap information about the configMap data to project" + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + } + ], + "description": "downwardAPI information about the downwardAPI data to project" + }, + "podCertificate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + } + ], + "description": "Projects an auto-rotating credential bundle (private key and certificate chain) that the pod can use either as a TLS client or server.\n\nKubelet generates a private key and uses it to send a PodCertificateRequest to the named signer. Once the signer approves the request and issues a certificate chain, Kubelet writes the key and certificate chain to the pod filesystem. The pod does not start until certificates have been issued for each podCertificate projected volume source in its spec.\n\nKubelet will begin trying to rotate the certificate at the time indicated by the signer using the PodCertificateRequest.Status.BeginRefreshAt timestamp.\n\nKubelet can write a single file, indicated by the credentialBundlePath field, or separate files, indicated by the keyPath and certificateChainPath fields.\n\nThe credential bundle is a single file in PEM format. The first PEM entry is the private key (in PKCS#8 format), and the remaining PEM entries are the certificate chain issued by the signer (typically, signers will return their certificate chain in leaf-to-root order).\n\nPrefer using the credential bundle format, since your application code can read it atomically. If you use keyPath and certificateChainPath, your application must make two separate file reads. If these coincide with a certificate rotation, it is possible that the private key and leaf certificate you read may not correspond to each other. Your application will need to check for this condition, and re-read until they are consistent.\n\nThe named signer controls chooses the format of the certificate it issues; consult the signer implementation's documentation to learn how to use the certificates it issues." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + } + ], + "description": "secret information about the secret data to project" + }, + "serviceAccountToken": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + ], + "description": "serviceAccountToken is information about the serviceAccountToken data to project" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {}, + "description": "Required. A pod affinity term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apps/v1/": { + "get": { + "description": "get available resources", + "operationId": "getAppsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ] + } + }, + "/apis/apps/v1/controllerrevisions": { + "get": { + "description": "list or watch objects of kind ControllerRevision", + "operationId": "listAppsV1ControllerRevisionForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/daemonsets": { + "get": { + "description": "list or watch objects of kind DaemonSet", + "operationId": "listAppsV1DaemonSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/deployments": { + "get": { + "description": "list or watch objects of kind Deployment", + "operationId": "listAppsV1DeploymentForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/namespaces/{namespace}/controllerrevisions": { + "delete": { + "description": "delete collection of ControllerRevision", + "operationId": "deleteAppsV1CollectionNamespacedControllerRevision", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ControllerRevision", + "operationId": "listAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ControllerRevision", + "operationId": "createAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}": { + "delete": { + "description": "delete a ControllerRevision", + "operationId": "deleteAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "get": { + "description": "read the specified ControllerRevision", + "operationId": "readAppsV1NamespacedControllerRevision", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ControllerRevision", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ControllerRevision", + "operationId": "patchAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ControllerRevision", + "operationId": "replaceAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets": { + "delete": { + "description": "delete collection of DaemonSet", + "operationId": "deleteAppsV1CollectionNamespacedDaemonSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind DaemonSet", + "operationId": "listAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a DaemonSet", + "operationId": "createAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}": { + "delete": { + "description": "delete a DaemonSet", + "operationId": "deleteAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified DaemonSet", + "operationId": "readAppsV1NamespacedDaemonSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified DaemonSet", + "operationId": "patchAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified DaemonSet", + "operationId": "replaceAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status": { + "get": { + "description": "read status of the specified DaemonSet", + "operationId": "readAppsV1NamespacedDaemonSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified DaemonSet", + "operationId": "patchAppsV1NamespacedDaemonSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified DaemonSet", + "operationId": "replaceAppsV1NamespacedDaemonSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments": { + "delete": { + "description": "delete collection of Deployment", + "operationId": "deleteAppsV1CollectionNamespacedDeployment", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Deployment", + "operationId": "listAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Deployment", + "operationId": "createAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}": { + "delete": { + "description": "delete a Deployment", + "operationId": "deleteAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "get": { + "description": "read the specified Deployment", + "operationId": "readAppsV1NamespacedDeployment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Deployment", + "operationId": "patchAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale": { + "get": { + "description": "read scale of the specified Deployment", + "operationId": "readAppsV1NamespacedDeploymentScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified Deployment", + "operationId": "patchAppsV1NamespacedDeploymentScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeploymentScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status": { + "get": { + "description": "read status of the specified Deployment", + "operationId": "readAppsV1NamespacedDeploymentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Deployment", + "operationId": "patchAppsV1NamespacedDeploymentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeploymentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets": { + "delete": { + "description": "delete collection of ReplicaSet", + "operationId": "deleteAppsV1CollectionNamespacedReplicaSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ReplicaSet", + "operationId": "listAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ReplicaSet", + "operationId": "createAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}": { + "delete": { + "description": "delete a ReplicaSet", + "operationId": "deleteAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale": { + "get": { + "description": "read scale of the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSetScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status": { + "get": { + "description": "read status of the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets": { + "delete": { + "description": "delete collection of StatefulSet", + "operationId": "deleteAppsV1CollectionNamespacedStatefulSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind StatefulSet", + "operationId": "listAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a StatefulSet", + "operationId": "createAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}": { + "delete": { + "description": "delete a StatefulSet", + "operationId": "deleteAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale": { + "get": { + "description": "read scale of the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSetScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status": { + "get": { + "description": "read status of the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/replicasets": { + "get": { + "description": "list or watch objects of kind ReplicaSet", + "operationId": "listAppsV1ReplicaSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/statefulsets": { + "get": { + "description": "list or watch objects of kind StatefulSet", + "operationId": "listAppsV1StatefulSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/controllerrevisions": { + "get": { + "description": "watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1ControllerRevisionListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/daemonsets": { + "get": { + "description": "watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1DaemonSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/deployments": { + "get": { + "description": "watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1DeploymentListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions": { + "get": { + "description": "watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedControllerRevisionList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}": { + "get": { + "description": "watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedControllerRevision", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ControllerRevision", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets": { + "get": { + "description": "watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedDaemonSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}": { + "get": { + "description": "watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedDaemonSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/deployments": { + "get": { + "description": "watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedDeploymentList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}": { + "get": { + "description": "watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedDeployment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/replicasets": { + "get": { + "description": "watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedReplicaSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}": { + "get": { + "description": "watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedReplicaSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets": { + "get": { + "description": "watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedStatefulSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}": { + "get": { + "description": "watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedStatefulSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/replicasets": { + "get": { + "description": "watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1ReplicaSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/statefulsets": { + "get": { + "description": "watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1StatefulSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_apps_v1_patched.json b/gen/openapi_v1/specs/apis_apps_v1_patched.json new file mode 100644 index 00000000..0c19d140 --- /dev/null +++ b/gen/openapi_v1/specs/apis_apps_v1_patched.json @@ -0,0 +1,15951 @@ +{ + "components": { + "schemas": { + "io.k8s.api.apps.v1.ControllerRevision": { + "description": "ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "data": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "revision": { + "default": 0, + "description": "Revision indicates the revision of the state represented by Data.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "revision" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ControllerRevisionList": { + "description": "ControllerRevisionList is a resource containing a list of ControllerRevision objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of ControllerRevisions", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ControllerRevisionList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSet": { + "description": "DaemonSet represents the configuration of a daemon set.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSetCondition": { + "description": "DaemonSetCondition describes the state of a DaemonSet at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of DaemonSet condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetList": { + "description": "DaemonSetList is a collection of daemon sets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "A list of daemon sets.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DaemonSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DaemonSetSpec": { + "description": "DaemonSetSpec is the specification of a daemon set.", + "properties": { + "minReadySeconds": { + "description": "The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready).", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + }, + "updateStrategy": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy" + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetStatus": { + "description": "DaemonSetStatus represents the current status of a daemon set.", + "properties": { + "collisionCount": { + "description": "Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a DaemonSet's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentNumberScheduled": { + "default": 0, + "description": "The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "desiredNumberScheduled": { + "default": 0, + "description": "The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "numberAvailable": { + "description": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds)", + "format": "int32", + "type": "integer" + }, + "numberMisscheduled": { + "default": 0, + "description": "The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", + "format": "int32", + "type": "integer" + }, + "numberReady": { + "default": 0, + "description": "numberReady is the number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "numberUnavailable": { + "description": "The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds)", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "The most recent generation observed by the daemon set controller.", + "format": "int64", + "type": "integer" + }, + "updatedNumberScheduled": { + "description": "The total number of nodes that are running updated daemon pod", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "currentNumberScheduled", + "numberMisscheduled", + "desiredNumberScheduled", + "numberReady" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DaemonSetUpdateStrategy": { + "description": "DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet.", + "properties": { + "rollingUpdate": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet" + }, + "type": { + "description": "Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.Deployment": { + "description": "Deployment enables declarative updates for Pods and ReplicaSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DeploymentCondition": { + "description": "DeploymentCondition describes the state of a deployment at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastUpdateTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of deployment condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentList": { + "description": "DeploymentList is a list of Deployments.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of Deployments.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "DeploymentList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.DeploymentSpec": { + "description": "DeploymentSpec is the specification of the desired behavior of the Deployment.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "paused": { + "description": "Indicates that the deployment is paused.", + "type": "boolean" + }, + "progressDeadlineSeconds": { + "description": "The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "strategy": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentStatus": { + "description": "DeploymentStatus is the most recently observed status of the Deployment.", + "properties": { + "availableReplicas": { + "description": "Total number of available non-terminating pods (ready for at least minReadySeconds) targeted by this deployment.", + "format": "int32", + "type": "integer" + }, + "collisionCount": { + "description": "Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a deployment's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "observedGeneration": { + "description": "The generation observed by the deployment controller.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "Total number of non-terminating pods targeted by this Deployment with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Total number of non-terminating pods targeted by this deployment (their labels match the selector).", + "format": "int32", + "type": "integer" + }, + "terminatingReplicas": { + "description": "Total number of terminating pods targeted by this deployment. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\n\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).", + "format": "int32", + "type": "integer" + }, + "unavailableReplicas": { + "description": "Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.", + "format": "int32", + "type": "integer" + }, + "updatedReplicas": { + "description": "Total number of non-terminating pods targeted by this deployment that have the desired template spec.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.DeploymentStrategy": { + "description": "DeploymentStrategy describes how to replace existing pods with new ones.", + "properties": { + "rollingUpdate": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment" + }, + "type": { + "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSet": { + "description": "ReplicaSet ensures that a specified number of pod replicas are running at any given time.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ReplicaSetCondition": { + "description": "ReplicaSetCondition describes the state of a replica set at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of replica set condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSetList": { + "description": "ReplicaSetList is a collection of ReplicaSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "ReplicaSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.ReplicaSetSpec": { + "description": "ReplicaSetSpec is the specification of a ReplicaSet.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "replicas": { + "description": "Replicas is the number of desired pods. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "format": "int32", + "type": "integer" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + }, + "required": [ + "selector" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.ReplicaSetStatus": { + "description": "ReplicaSetStatus represents the current status of a ReplicaSet.", + "properties": { + "availableReplicas": { + "description": "The number of available non-terminating pods (ready for at least minReadySeconds) for this replica set.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a replica set's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "fullyLabeledReplicas": { + "description": "The number of non-terminating pods that have labels matching the labels of the pod template of the replicaset.", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "ObservedGeneration reflects the generation of the most recently observed ReplicaSet.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "The number of non-terminating pods targeted by this ReplicaSet with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "Replicas is the most recently observed number of non-terminating pods. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset", + "format": "int32", + "type": "integer" + }, + "terminatingReplicas": { + "description": "The number of terminating pods for this replica set. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\n\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateDaemonSet": { + "description": "Spec to control the desired behavior of daemon set rolling update.", + "properties": { + "maxSurge": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "maxUnavailable": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateDeployment": { + "description": "Spec to control the desired behavior of rolling update.", + "properties": { + "maxSurge": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "maxUnavailable": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy": { + "description": "RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.", + "properties": { + "maxUnavailable": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "partition": { + "description": "Partition indicates the ordinal at which the StatefulSet should be partitioned for updates. During a rolling update, all pods from ordinal Replicas-1 to Partition are updated. All pods from ordinal Partition-1 to 0 remain untouched. This is helpful in being able to do a canary based deployment. The default value is 0.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSet": { + "description": "StatefulSet represents a set of pods with consistent identities. Identities are defined as:\n - Network: A single stable DNS and hostname.\n - Storage: As many VolumeClaims as requested.\n\nThe StatefulSet guarantees that a given network identity will always map to the same storage identity.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.StatefulSetCondition": { + "description": "StatefulSetCondition describes the state of a statefulset at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "A human readable message indicating details about the transition.", + "type": "string" + }, + "reason": { + "description": "The reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of statefulset condition.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetList": { + "description": "StatefulSetList is a collection of StatefulSets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is the list of stateful sets.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "apps", + "kind": "StatefulSetList", + "version": "v1" + } + ] + }, + "io.k8s.api.apps.v1.StatefulSetOrdinals": { + "description": "StatefulSetOrdinals describes the policy used for replica ordinal assignment in this StatefulSet.", + "properties": { + "start": { + "default": 0, + "description": "start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range:\n [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas).\nIf unset, defaults to 0. Replica indices will be in the range:\n [0, .spec.replicas).", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy": { + "description": "StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.", + "properties": { + "whenDeleted": { + "description": "WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.", + "type": "string" + }, + "whenScaled": { + "description": "WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetSpec": { + "description": "A StatefulSetSpec is the specification of a StatefulSet.", + "properties": { + "minReadySeconds": { + "description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)", + "format": "int32", + "type": "integer" + }, + "ordinals": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals" + }, + "persistentVolumeClaimRetentionPolicy": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy" + }, + "podManagementPolicy": { + "description": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", + "type": "string" + }, + "replicas": { + "description": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", + "format": "int32", + "type": "integer" + }, + "revisionHistoryLimit": { + "description": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", + "format": "int32", + "type": "integer" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "serviceName": { + "default": "", + "description": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", + "type": "string" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + }, + "updateStrategy": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy" + }, + "volumeClaimTemplates": { + "description": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "selector", + "template" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetStatus": { + "description": "StatefulSetStatus represents the current state of a StatefulSet.", + "properties": { + "availableReplicas": { + "default": 0, + "description": "Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset.", + "format": "int32", + "type": "integer" + }, + "collisionCount": { + "description": "collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", + "format": "int32", + "type": "integer" + }, + "conditions": { + "description": "Represents the latest available observations of a statefulset's current state.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentReplicas": { + "description": "currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.", + "format": "int32", + "type": "integer" + }, + "currentRevision": { + "description": "currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.", + "format": "int64", + "type": "integer" + }, + "readyReplicas": { + "description": "readyReplicas is the number of pods created for this StatefulSet with a Ready Condition.", + "format": "int32", + "type": "integer" + }, + "replicas": { + "default": 0, + "description": "replicas is the number of Pods created by the StatefulSet controller.", + "format": "int32", + "type": "integer" + }, + "updateRevision": { + "description": "updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)", + "type": "string" + }, + "updatedReplicas": { + "description": "updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.apps.v1.StatefulSetUpdateStrategy": { + "description": "StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy.", + "properties": { + "rollingUpdate": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy" + }, + "type": { + "description": "Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.Scale": { + "description": "Scale represents a scaling request for a resource.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.ScaleSpec": { + "description": "ScaleSpec describes the attributes of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the desired number of instances for the scaled object.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v1.ScaleStatus": { + "description": "ScaleStatus represents the current status of a scale subresource.", + "properties": { + "replicas": { + "default": 0, + "description": "replicas is the actual number of observed instances of the scaled object.", + "format": "int32", + "type": "integer" + }, + "selector": { + "description": "selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/", + "type": "string" + } + }, + "required": [ + "replicas" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + }, + "podAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + }, + "podAntiAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + }, + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "fileKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + }, + "secretKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "preStop": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "sleep": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ModifyVolumeStatus": { + "description": "ModifyVolumeStatus represents the status object of ControllerModifyVolume operation", + "properties": { + "status": { + "default": "", + "description": "status is the status of the ControllerModifyVolume operation. It can be in any of following states:\n - Pending\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\n the specified VolumeAttributesClass not existing.\n - InProgress\n InProgress indicates that the volume is being modified.\n - Infeasible\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\n\t resolve the error, a valid VolumeAttributesClass needs to be specified.\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.", + "type": "string" + }, + "targetVolumeAttributesClassName": { + "description": "targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled", + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeClaim": { + "description": "PersistentVolumeClaim is a user's request for and claim to a persistent volume", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "PersistentVolumeClaim", + "version": "v1" + } + ] + }, + "io.k8s.api.core.v1.PersistentVolumeClaimCondition": { + "description": "PersistentVolumeClaimCondition contains details about state of pvc", + "properties": { + "lastProbeTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message is the human-readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"Resizing\" that means the underlying persistent volume is being resized.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required", + "type": "string" + }, + "type": { + "default": "", + "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "dataSource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + }, + "dataSourceRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimStatus": { + "description": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "properties": { + "accessModes": { + "description": "accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "allocatedResourceStatuses": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nClaimResourceStatus can be in any of following states:\n\t- ControllerResizeInProgress:\n\t\tState set when resize controller starts resizing the volume in control-plane.\n\t- ControllerResizeFailed:\n\t\tState set when resize has failed in resize controller with a terminal error.\n\t- NodeResizePending:\n\t\tState set when resize controller has finished resizing the volume but further resizing of\n\t\tvolume is needed on the node.\n\t- NodeResizeInProgress:\n\t\tState set when kubelet starts resizing the volume.\n\t- NodeResizeFailed:\n\t\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\n\t\tNodeResizeFailed.\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\n\t- pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"ControllerResizeFailed\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizePending\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeInProgress\"\n - pvc.status.allocatedResourceStatus['storage'] = \"NodeResizeFailed\"\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\n\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object", + "x-kubernetes-map-type": "granular" + }, + "allocatedResources": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\n\t* Un-prefixed keys:\n\t\t- storage - the capacity of the volume.\n\t* Custom resources must use implementation-defined prefixed names such as \"example.com/my-custom-resource\"\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\n\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\n\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.", + "type": "object" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity represents the actual resources of the underlying volume.", + "type": "object" + }, + "conditions": { + "description": "conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentVolumeAttributesClassName": { + "description": "currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim", + "type": "string" + }, + "modifyVolumeStatus": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus" + }, + "phase": { + "description": "phase represents the current phase of PersistentVolumeClaim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "namespaceSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "dnsConfig": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "workloadRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "nullable": true + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "capabilities": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + }, + "azureDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + }, + "azureFile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + }, + "cephfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + }, + "cinder": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + }, + "csi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + }, + "emptyDir": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + }, + "ephemeral": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + }, + "fc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + }, + "flexVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + }, + "flocker": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + }, + "gcePersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + }, + "gitRepo": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + }, + "glusterfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + }, + "hostPath": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + }, + "image": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + }, + "iscsi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + }, + "persistentVolumeClaim": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + }, + "photonPersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + }, + "portworxVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + }, + "projected": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + }, + "quobyte": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + }, + "rbd": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + }, + "scaleIO": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + }, + "storageos": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + }, + "vsphereVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + }, + "podCertificate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + }, + "serviceAccountToken": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/apps/v1/": { + "get": { + "description": "get available resources", + "operationId": "getAppsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ] + } + }, + "/apis/apps/v1/controllerrevisions": { + "get": { + "description": "list or watch objects of kind ControllerRevision", + "operationId": "listAppsV1ControllerRevisionForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/daemonsets": { + "get": { + "description": "list or watch objects of kind DaemonSet", + "operationId": "listAppsV1DaemonSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/deployments": { + "get": { + "description": "list or watch objects of kind Deployment", + "operationId": "listAppsV1DeploymentForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/namespaces/{namespace}/controllerrevisions": { + "delete": { + "description": "delete collection of ControllerRevision", + "operationId": "deleteAppsV1CollectionNamespacedControllerRevision", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ControllerRevision", + "operationId": "listAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ControllerRevision", + "operationId": "createAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}": { + "delete": { + "description": "delete a ControllerRevision", + "operationId": "deleteAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "get": { + "description": "read the specified ControllerRevision", + "operationId": "readAppsV1NamespacedControllerRevision", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ControllerRevision", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ControllerRevision", + "operationId": "patchAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ControllerRevision", + "operationId": "replaceAppsV1NamespacedControllerRevision", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ControllerRevision" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets": { + "delete": { + "description": "delete collection of DaemonSet", + "operationId": "deleteAppsV1CollectionNamespacedDaemonSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind DaemonSet", + "operationId": "listAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a DaemonSet", + "operationId": "createAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}": { + "delete": { + "description": "delete a DaemonSet", + "operationId": "deleteAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified DaemonSet", + "operationId": "readAppsV1NamespacedDaemonSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified DaemonSet", + "operationId": "patchAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified DaemonSet", + "operationId": "replaceAppsV1NamespacedDaemonSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status": { + "get": { + "description": "read status of the specified DaemonSet", + "operationId": "readAppsV1NamespacedDaemonSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified DaemonSet", + "operationId": "patchAppsV1NamespacedDaemonSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified DaemonSet", + "operationId": "replaceAppsV1NamespacedDaemonSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DaemonSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments": { + "delete": { + "description": "delete collection of Deployment", + "operationId": "deleteAppsV1CollectionNamespacedDeployment", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Deployment", + "operationId": "listAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.DeploymentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Deployment", + "operationId": "createAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}": { + "delete": { + "description": "delete a Deployment", + "operationId": "deleteAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "get": { + "description": "read the specified Deployment", + "operationId": "readAppsV1NamespacedDeployment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Deployment", + "operationId": "patchAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeployment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale": { + "get": { + "description": "read scale of the specified Deployment", + "operationId": "readAppsV1NamespacedDeploymentScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified Deployment", + "operationId": "patchAppsV1NamespacedDeploymentScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeploymentScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status": { + "get": { + "description": "read status of the specified Deployment", + "operationId": "readAppsV1NamespacedDeploymentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Deployment", + "operationId": "patchAppsV1NamespacedDeploymentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Deployment", + "operationId": "replaceAppsV1NamespacedDeploymentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.Deployment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets": { + "delete": { + "description": "delete collection of ReplicaSet", + "operationId": "deleteAppsV1CollectionNamespacedReplicaSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ReplicaSet", + "operationId": "listAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ReplicaSet", + "operationId": "createAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}": { + "delete": { + "description": "delete a ReplicaSet", + "operationId": "deleteAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale": { + "get": { + "description": "read scale of the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSetScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status": { + "get": { + "description": "read status of the specified ReplicaSet", + "operationId": "readAppsV1NamespacedReplicaSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ReplicaSet", + "operationId": "patchAppsV1NamespacedReplicaSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ReplicaSet", + "operationId": "replaceAppsV1NamespacedReplicaSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets": { + "delete": { + "description": "delete collection of StatefulSet", + "operationId": "deleteAppsV1CollectionNamespacedStatefulSet", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind StatefulSet", + "operationId": "listAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a StatefulSet", + "operationId": "createAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}": { + "delete": { + "description": "delete a StatefulSet", + "operationId": "deleteAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "get": { + "description": "read the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "put": { + "description": "replace the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSet", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale": { + "get": { + "description": "read scale of the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSetScale", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Scale", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update scale of the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + }, + "put": { + "description": "replace scale of the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSetScale", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.Scale" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "Scale", + "version": "v1" + } + } + }, + "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status": { + "get": { + "description": "read status of the specified StatefulSet", + "operationId": "readAppsV1NamespacedStatefulSetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified StatefulSet", + "operationId": "patchAppsV1NamespacedStatefulSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified StatefulSet", + "operationId": "replaceAppsV1NamespacedStatefulSetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSet" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + } + }, + "/apis/apps/v1/replicasets": { + "get": { + "description": "list or watch objects of kind ReplicaSet", + "operationId": "listAppsV1ReplicaSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/statefulsets": { + "get": { + "description": "list or watch objects of kind StatefulSet", + "operationId": "listAppsV1StatefulSetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.apps.v1.StatefulSetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/controllerrevisions": { + "get": { + "description": "watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1ControllerRevisionListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/daemonsets": { + "get": { + "description": "watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1DaemonSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/deployments": { + "get": { + "description": "watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1DeploymentListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions": { + "get": { + "description": "watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedControllerRevisionList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}": { + "get": { + "description": "watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedControllerRevision", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ControllerRevision", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ControllerRevision", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets": { + "get": { + "description": "watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedDaemonSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}": { + "get": { + "description": "watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedDaemonSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "DaemonSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the DaemonSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/deployments": { + "get": { + "description": "watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedDeploymentList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}": { + "get": { + "description": "watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedDeployment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "Deployment", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Deployment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/replicasets": { + "get": { + "description": "watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedReplicaSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}": { + "get": { + "description": "watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedReplicaSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ReplicaSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets": { + "get": { + "description": "watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1NamespacedStatefulSetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}": { + "get": { + "description": "watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAppsV1NamespacedStatefulSet", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the StatefulSet", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/replicasets": { + "get": { + "description": "watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1ReplicaSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "ReplicaSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/apps/v1/watch/statefulsets": { + "get": { + "description": "watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAppsV1StatefulSetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "apps_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "apps", + "kind": "StatefulSet", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_autoscaling_v1.json b/gen/openapi_v1/specs/apis_autoscaling_v1.json new file mode 100644 index 00000000..a6a895b4 --- /dev/null +++ b/gen/openapi_v1/specs/apis_autoscaling_v1.json @@ -0,0 +1,3336 @@ +{ + "components": { + "schemas": { + "io.k8s.api.autoscaling.v1.CrossVersionObjectReference": { + "description": "CrossVersionObjectReference contains enough information to let you identify the referred resource.", + "properties": { + "apiVersion": { + "description": "apiVersion is the API version of the referent", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler": { + "description": "configuration of a horizontal pod autoscaler.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec" + } + ], + "default": {}, + "description": "spec defines the behaviour of autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus" + } + ], + "default": {}, + "description": "status is the current information about the autoscaler." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList": { + "description": "list of horizontal pod autoscaler objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of horizontal pod autoscaler objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscalerList", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec": { + "description": "specification of a horizontal pod autoscaler.", + "properties": { + "maxReplicas": { + "default": 0, + "description": "maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.", + "format": "int32", + "type": "integer" + }, + "minReplicas": { + "description": "minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.", + "format": "int32", + "type": "integer" + }, + "scaleTargetRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference" + } + ], + "default": {}, + "description": "reference to scaled resource; horizontal pod autoscaler will learn the current resource consumption and will set the desired number of pods by using its Scale subresource." + }, + "targetCPUUtilizationPercentage": { + "description": "targetCPUUtilizationPercentage is the target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "scaleTargetRef", + "maxReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus": { + "description": "current status of a horizontal pod autoscaler", + "properties": { + "currentCPUUtilizationPercentage": { + "description": "currentCPUUtilizationPercentage is the current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU.", + "format": "int32", + "type": "integer" + }, + "currentReplicas": { + "default": 0, + "description": "currentReplicas is the current number of replicas of pods managed by this autoscaler.", + "format": "int32", + "type": "integer" + }, + "desiredReplicas": { + "default": 0, + "description": "desiredReplicas is the desired number of replicas of pods managed by this autoscaler.", + "format": "int32", + "type": "integer" + }, + "lastScaleTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods; used by the autoscaler to control how often the number of pods is changed." + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed by this autoscaler.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "currentReplicas", + "desiredReplicas" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/autoscaling/v1/": { + "get": { + "description": "get available resources", + "operationId": "getAutoscalingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ] + } + }, + "/apis/autoscaling/v1/horizontalpodautoscalers": { + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers": { + "delete": { + "description": "delete collection of HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a HorizontalPodAutoscaler", + "operationId": "createAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "delete": { + "description": "delete a HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "get": { + "description": "read the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV1NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "put": { + "description": "replace the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status": { + "get": { + "description": "read status of the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/watch/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV1NamespacedHorizontalPodAutoscalerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "get": { + "description": "watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAutoscalingV1NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_autoscaling_v1_patched.json b/gen/openapi_v1/specs/apis_autoscaling_v1_patched.json new file mode 100644 index 00000000..3aebbd08 --- /dev/null +++ b/gen/openapi_v1/specs/apis_autoscaling_v1_patched.json @@ -0,0 +1,3251 @@ +{ + "components": { + "schemas": { + "io.k8s.api.autoscaling.v1.CrossVersionObjectReference": { + "description": "CrossVersionObjectReference contains enough information to let you identify the referred resource.", + "properties": { + "apiVersion": { + "description": "apiVersion is the API version of the referent", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler": { + "description": "configuration of a horizontal pod autoscaler.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList": { + "description": "list of horizontal pod autoscaler objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of horizontal pod autoscaler objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscalerList", + "version": "v1" + } + ] + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec": { + "description": "specification of a horizontal pod autoscaler.", + "properties": { + "maxReplicas": { + "default": 0, + "description": "maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.", + "format": "int32", + "type": "integer" + }, + "minReplicas": { + "description": "minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.", + "format": "int32", + "type": "integer" + }, + "scaleTargetRef": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference" + }, + "targetCPUUtilizationPercentage": { + "description": "targetCPUUtilizationPercentage is the target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "scaleTargetRef", + "maxReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus": { + "description": "current status of a horizontal pod autoscaler", + "properties": { + "currentCPUUtilizationPercentage": { + "description": "currentCPUUtilizationPercentage is the current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU.", + "format": "int32", + "type": "integer" + }, + "currentReplicas": { + "default": 0, + "description": "currentReplicas is the current number of replicas of pods managed by this autoscaler.", + "format": "int32", + "type": "integer" + }, + "desiredReplicas": { + "default": 0, + "description": "desiredReplicas is the desired number of replicas of pods managed by this autoscaler.", + "format": "int32", + "type": "integer" + }, + "lastScaleTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed by this autoscaler.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "currentReplicas", + "desiredReplicas" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/autoscaling/v1/": { + "get": { + "description": "get available resources", + "operationId": "getAutoscalingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ] + } + }, + "/apis/autoscaling/v1/horizontalpodautoscalers": { + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers": { + "delete": { + "description": "delete collection of HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a HorizontalPodAutoscaler", + "operationId": "createAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "delete": { + "description": "delete a HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "get": { + "description": "read the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV1NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "put": { + "description": "replace the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV1NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status": { + "get": { + "description": "read status of the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + } + }, + "/apis/autoscaling/v1/watch/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV1NamespacedHorizontalPodAutoscalerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "get": { + "description": "watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAutoscalingV1NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_autoscaling_v2.json b/gen/openapi_v1/specs/apis_autoscaling_v2.json new file mode 100644 index 00000000..da9e7ef0 --- /dev/null +++ b/gen/openapi_v1/specs/apis_autoscaling_v2.json @@ -0,0 +1,4053 @@ +{ + "components": { + "schemas": { + "io.k8s.api.autoscaling.v2.ContainerResourceMetricSource": { + "description": "ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "properties": { + "container": { + "default": "", + "description": "container is the name of the container in the pods of the scaling target", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + ], + "default": {}, + "description": "target specifies the target value for the given metric" + } + }, + "required": [ + "name", + "target", + "container" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus": { + "description": "ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "properties": { + "container": { + "default": "", + "description": "container is the name of the container in the pods of the scaling target", + "type": "string" + }, + "current": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + } + ], + "default": {}, + "description": "current contains the current value for the given metric" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + } + }, + "required": [ + "name", + "current", + "container" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.CrossVersionObjectReference": { + "description": "CrossVersionObjectReference contains enough information to let you identify the referred resource.", + "properties": { + "apiVersion": { + "description": "apiVersion is the API version of the referent", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ExternalMetricSource": { + "description": "ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).", + "properties": { + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + ], + "default": {}, + "description": "target specifies the target value for the given metric" + } + }, + "required": [ + "metric", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ExternalMetricStatus": { + "description": "ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.", + "properties": { + "current": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + } + ], + "default": {}, + "description": "current contains the current value for the given metric" + }, + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + } + }, + "required": [ + "metric", + "current" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HPAScalingPolicy": { + "description": "HPAScalingPolicy is a single policy which must hold true for a specified past interval.", + "properties": { + "periodSeconds": { + "default": 0, + "description": "periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min).", + "format": "int32", + "type": "integer" + }, + "type": { + "default": "", + "description": "type is used to specify the scaling policy.", + "type": "string" + }, + "value": { + "default": 0, + "description": "value contains the amount of change which is permitted by the policy. It must be greater than zero", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "type", + "value", + "periodSeconds" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HPAScalingRules": { + "description": "HPAScalingRules configures the scaling behavior for one direction via scaling Policy Rules and a configurable metric tolerance.\n\nScaling Policy Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen.\n\nThe tolerance is applied to the metric values and prevents scaling too eagerly for small metric variations. (Note that setting a tolerance requires the beta HPAConfigurableTolerance feature gate to be enabled.)", + "properties": { + "policies": { + "description": "policies is a list of potential scaling polices which can be used during scaling. If not set, use the default values: - For scale up: allow doubling the number of pods, or an absolute change of 4 pods in a 15s window. - For scale down: allow all pods to be removed in a 15s window.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "selectPolicy": { + "description": "selectPolicy is used to specify which policy should be used. If not set, the default value Max is used.", + "type": "string" + }, + "stabilizationWindowSeconds": { + "description": "stabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long).", + "format": "int32", + "type": "integer" + }, + "tolerance": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "tolerance is the tolerance on the ratio between the current and desired metric value under which no updates are made to the desired number of replicas (e.g. 0.01 for 1%). Must be greater than or equal to zero. If not set, the default cluster-wide tolerance is applied (by default 10%).\n\nFor example, if autoscaling is configured with a memory consumption target of 100Mi, and scale-down and scale-up tolerances of 5% and 1% respectively, scaling will be triggered when the actual consumption falls below 95Mi or exceeds 101Mi.\n\nThis is an beta field and requires the HPAConfigurableTolerance feature gate to be enabled." + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler": { + "description": "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "metadata is the standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec" + } + ], + "default": {}, + "description": "spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus" + } + ], + "default": {}, + "description": "status is the current information about the autoscaler." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + ] + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior": { + "description": "HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively).", + "properties": { + "scaleDown": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules" + } + ], + "description": "scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used)." + }, + "scaleUp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules" + } + ], + "description": "scaleUp is scaling policy for scaling Up. If not set, the default value is the higher of:\n * increase no more than 4 pods per 60 seconds\n * double the number of pods per 60 seconds\nNo stabilization is used." + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition": { + "description": "HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the last time the condition transitioned from one status to another" + }, + "message": { + "description": "message is a human-readable explanation containing details about the transition", + "type": "string" + }, + "reason": { + "description": "reason is the reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "status is the status of the condition (True, False, Unknown)", + "type": "string" + }, + "type": { + "default": "", + "description": "type describes the current condition", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList": { + "description": "HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of horizontal pod autoscaler objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "metadata is the standard list metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscalerList", + "version": "v2" + } + ] + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec": { + "description": "HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler.", + "properties": { + "behavior": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior" + } + ], + "description": "behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used." + }, + "maxReplicas": { + "default": 0, + "description": "maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas.", + "format": "int32", + "type": "integer" + }, + "metrics": { + "description": "metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "minReplicas": { + "description": "minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.", + "format": "int32", + "type": "integer" + }, + "scaleTargetRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + } + ], + "default": {}, + "description": "scaleTargetRef points to the target resource to scale, and is used to the pods for which metrics should be collected, as well as to actually change the replica count." + } + }, + "required": [ + "scaleTargetRef", + "maxReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus": { + "description": "HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler.", + "properties": { + "conditions": { + "description": "conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentMetrics": { + "description": "currentMetrics is the last read state of the metrics used by this autoscaler.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "currentReplicas": { + "description": "currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler.", + "format": "int32", + "type": "integer" + }, + "desiredReplicas": { + "default": 0, + "description": "desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler.", + "format": "int32", + "type": "integer" + }, + "lastScaleTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, used by the autoscaler to control how often the number of pods is changed." + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed by this autoscaler.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "desiredReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricIdentifier": { + "description": "MetricIdentifier defines the name and optionally selector for a metric", + "properties": { + "name": { + "default": "", + "description": "name is the name of the given metric", + "type": "string" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "selector is the string-encoded form of a standard kubernetes label selector for the given metric When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping. When unset, just the metricName will be used to gather metrics." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricSpec": { + "description": "MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once).", + "properties": { + "containerResource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource" + } + ], + "description": "containerResource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source." + }, + "external": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource" + } + ], + "description": "external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster)." + }, + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource" + } + ], + "description": "object refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object)." + }, + "pods": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource" + } + ], + "description": "pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value." + }, + "resource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource" + } + ], + "description": "resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source." + }, + "type": { + "default": "", + "description": "type is the type of metric source. It should be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricStatus": { + "description": "MetricStatus describes the last-read state of a single metric.", + "properties": { + "containerResource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus" + } + ], + "description": "container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source." + }, + "external": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus" + } + ], + "description": "external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster)." + }, + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus" + } + ], + "description": "object refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object)." + }, + "pods": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus" + } + ], + "description": "pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value." + }, + "resource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus" + } + ], + "description": "resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source." + }, + "type": { + "default": "", + "description": "type is the type of metric source. It will be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricTarget": { + "description": "MetricTarget defines the target value, average value, or average utilization of a specific metric", + "properties": { + "averageUtilization": { + "description": "averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type", + "format": "int32", + "type": "integer" + }, + "averageValue": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "averageValue is the target value of the average of the metric across all relevant pods (as a quantity)" + }, + "type": { + "default": "", + "description": "type represents whether the metric type is Utilization, Value, or AverageValue", + "type": "string" + }, + "value": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "value is the target value of the metric (as a quantity)." + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricValueStatus": { + "description": "MetricValueStatus holds the current value for a metric", + "properties": { + "averageUtilization": { + "description": "currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods.", + "format": "int32", + "type": "integer" + }, + "averageValue": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "averageValue is the current value of the average of the metric across all relevant pods (as a quantity)" + }, + "value": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "value is the current value of the metric (as a quantity)." + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ObjectMetricSource": { + "description": "ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "properties": { + "describedObject": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + } + ], + "default": {}, + "description": "describedObject specifies the descriptions of a object,such as kind,name apiVersion" + }, + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + ], + "default": {}, + "description": "target specifies the target value for the given metric" + } + }, + "required": [ + "describedObject", + "target", + "metric" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ObjectMetricStatus": { + "description": "ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "properties": { + "current": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + } + ], + "default": {}, + "description": "current contains the current value for the given metric" + }, + "describedObject": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + } + ], + "default": {}, + "description": "DescribedObject specifies the descriptions of a object,such as kind,name apiVersion" + }, + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + } + }, + "required": [ + "metric", + "current", + "describedObject" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.PodsMetricSource": { + "description": "PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.", + "properties": { + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + ], + "default": {}, + "description": "target specifies the target value for the given metric" + } + }, + "required": [ + "metric", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.PodsMetricStatus": { + "description": "PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).", + "properties": { + "current": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + } + ], + "default": {}, + "description": "current contains the current value for the given metric" + }, + "metric": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + ], + "default": {}, + "description": "metric identifies the target metric by name and selector" + } + }, + "required": [ + "metric", + "current" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ResourceMetricSource": { + "description": "ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "properties": { + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + }, + "target": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + ], + "default": {}, + "description": "target specifies the target value for the given metric" + } + }, + "required": [ + "name", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ResourceMetricStatus": { + "description": "ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "properties": { + "current": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + } + ], + "default": {}, + "description": "current contains the current value for the given metric" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + } + }, + "required": [ + "name", + "current" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/autoscaling/v2/": { + "get": { + "description": "get available resources", + "operationId": "getAutoscalingV2APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ] + } + }, + "/apis/autoscaling/v2/horizontalpodautoscalers": { + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV2HorizontalPodAutoscalerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers": { + "delete": { + "description": "delete collection of HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV2CollectionNamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a HorizontalPodAutoscaler", + "operationId": "createAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "delete": { + "description": "delete a HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "get": { + "description": "read the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV2NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "put": { + "description": "replace the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status": { + "get": { + "description": "read status of the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "put": { + "description": "replace status of the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/watch/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV2HorizontalPodAutoscalerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV2NamespacedHorizontalPodAutoscalerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "get": { + "description": "watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAutoscalingV2NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_autoscaling_v2_patched.json b/gen/openapi_v1/specs/apis_autoscaling_v2_patched.json new file mode 100644 index 00000000..c332395c --- /dev/null +++ b/gen/openapi_v1/specs/apis_autoscaling_v2_patched.json @@ -0,0 +1,3741 @@ +{ + "components": { + "schemas": { + "io.k8s.api.autoscaling.v2.ContainerResourceMetricSource": { + "description": "ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "properties": { + "container": { + "default": "", + "description": "container is the name of the container in the pods of the scaling target", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + }, + "required": [ + "name", + "target", + "container" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus": { + "description": "ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "properties": { + "container": { + "default": "", + "description": "container is the name of the container in the pods of the scaling target", + "type": "string" + }, + "current": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + } + }, + "required": [ + "name", + "current", + "container" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.CrossVersionObjectReference": { + "description": "CrossVersionObjectReference contains enough information to let you identify the referred resource.", + "properties": { + "apiVersion": { + "description": "apiVersion is the API version of the referent", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ExternalMetricSource": { + "description": "ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).", + "properties": { + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + }, + "required": [ + "metric", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ExternalMetricStatus": { + "description": "ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.", + "properties": { + "current": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + }, + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + }, + "required": [ + "metric", + "current" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HPAScalingPolicy": { + "description": "HPAScalingPolicy is a single policy which must hold true for a specified past interval.", + "properties": { + "periodSeconds": { + "default": 0, + "description": "periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min).", + "format": "int32", + "type": "integer" + }, + "type": { + "default": "", + "description": "type is used to specify the scaling policy.", + "type": "string" + }, + "value": { + "default": 0, + "description": "value contains the amount of change which is permitted by the policy. It must be greater than zero", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "type", + "value", + "periodSeconds" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HPAScalingRules": { + "description": "HPAScalingRules configures the scaling behavior for one direction via scaling Policy Rules and a configurable metric tolerance.\n\nScaling Policy Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen.\n\nThe tolerance is applied to the metric values and prevents scaling too eagerly for small metric variations. (Note that setting a tolerance requires the beta HPAConfigurableTolerance feature gate to be enabled.)", + "properties": { + "policies": { + "description": "policies is a list of potential scaling polices which can be used during scaling. If not set, use the default values: - For scale up: allow doubling the number of pods, or an absolute change of 4 pods in a 15s window. - For scale down: allow all pods to be removed in a 15s window.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "selectPolicy": { + "description": "selectPolicy is used to specify which policy should be used. If not set, the default value Max is used.", + "type": "string" + }, + "stabilizationWindowSeconds": { + "description": "stabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long).", + "format": "int32", + "type": "integer" + }, + "tolerance": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler": { + "description": "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + ] + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior": { + "description": "HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively).", + "properties": { + "scaleDown": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules" + }, + "scaleUp": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition": { + "description": "HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message is a human-readable explanation containing details about the transition", + "type": "string" + }, + "reason": { + "description": "reason is the reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "status is the status of the condition (True, False, Unknown)", + "type": "string" + }, + "type": { + "default": "", + "description": "type describes the current condition", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList": { + "description": "HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of horizontal pod autoscaler objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "autoscaling", + "kind": "HorizontalPodAutoscalerList", + "version": "v2" + } + ] + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec": { + "description": "HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler.", + "properties": { + "behavior": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior" + }, + "maxReplicas": { + "default": 0, + "description": "maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas.", + "format": "int32", + "type": "integer" + }, + "metrics": { + "description": "metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "minReplicas": { + "description": "minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.", + "format": "int32", + "type": "integer" + }, + "scaleTargetRef": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + } + }, + "required": [ + "scaleTargetRef", + "maxReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus": { + "description": "HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler.", + "properties": { + "conditions": { + "description": "conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentMetrics": { + "description": "currentMetrics is the last read state of the metrics used by this autoscaler.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "currentReplicas": { + "description": "currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler.", + "format": "int32", + "type": "integer" + }, + "desiredReplicas": { + "default": 0, + "description": "desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler.", + "format": "int32", + "type": "integer" + }, + "lastScaleTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "observedGeneration": { + "description": "observedGeneration is the most recent generation observed by this autoscaler.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "desiredReplicas" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricIdentifier": { + "description": "MetricIdentifier defines the name and optionally selector for a metric", + "properties": { + "name": { + "default": "", + "description": "name is the name of the given metric", + "type": "string" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricSpec": { + "description": "MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once).", + "properties": { + "containerResource": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource" + }, + "external": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource" + }, + "object": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource" + }, + "pods": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource" + }, + "resource": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource" + }, + "type": { + "default": "", + "description": "type is the type of metric source. It should be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricStatus": { + "description": "MetricStatus describes the last-read state of a single metric.", + "properties": { + "containerResource": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus" + }, + "external": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus" + }, + "object": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus" + }, + "pods": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus" + }, + "resource": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus" + }, + "type": { + "default": "", + "description": "type is the type of metric source. It will be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricTarget": { + "description": "MetricTarget defines the target value, average value, or average utilization of a specific metric", + "properties": { + "averageUtilization": { + "description": "averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type", + "format": "int32", + "type": "integer" + }, + "averageValue": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "type": { + "default": "", + "description": "type represents whether the metric type is Utilization, Value, or AverageValue", + "type": "string" + }, + "value": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.MetricValueStatus": { + "description": "MetricValueStatus holds the current value for a metric", + "properties": { + "averageUtilization": { + "description": "currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods.", + "format": "int32", + "type": "integer" + }, + "averageValue": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "value": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ObjectMetricSource": { + "description": "ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "properties": { + "describedObject": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + }, + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + }, + "required": [ + "describedObject", + "target", + "metric" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ObjectMetricStatus": { + "description": "ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "properties": { + "current": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + }, + "describedObject": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference" + }, + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + }, + "required": [ + "metric", + "current", + "describedObject" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.PodsMetricSource": { + "description": "PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.", + "properties": { + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + }, + "required": [ + "metric", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.PodsMetricStatus": { + "description": "PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).", + "properties": { + "current": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + }, + "metric": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier" + } + }, + "required": [ + "metric", + "current" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ResourceMetricSource": { + "description": "ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "properties": { + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + }, + "target": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget" + } + }, + "required": [ + "name", + "target" + ], + "type": "object" + }, + "io.k8s.api.autoscaling.v2.ResourceMetricStatus": { + "description": "ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "properties": { + "current": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus" + }, + "name": { + "default": "", + "description": "name is the name of the resource in question.", + "type": "string" + } + }, + "required": [ + "name", + "current" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/autoscaling/v2/": { + "get": { + "description": "get available resources", + "operationId": "getAutoscalingV2APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ] + } + }, + "/apis/autoscaling/v2/horizontalpodautoscalers": { + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV2HorizontalPodAutoscalerForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers": { + "delete": { + "description": "delete collection of HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV2CollectionNamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "get": { + "description": "list or watch objects of kind HorizontalPodAutoscaler", + "operationId": "listAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a HorizontalPodAutoscaler", + "operationId": "createAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "delete": { + "description": "delete a HorizontalPodAutoscaler", + "operationId": "deleteAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "get": { + "description": "read the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV2NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "put": { + "description": "replace the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV2NamespacedHorizontalPodAutoscaler", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status": { + "get": { + "description": "read status of the specified HorizontalPodAutoscaler", + "operationId": "readAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified HorizontalPodAutoscaler", + "operationId": "patchAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "put": { + "description": "replace status of the specified HorizontalPodAutoscaler", + "operationId": "replaceAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + } + }, + "/apis/autoscaling/v2/watch/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV2HorizontalPodAutoscalerListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers": { + "get": { + "description": "watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchAutoscalingV2NamespacedHorizontalPodAutoscalerList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}": { + "get": { + "description": "watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchAutoscalingV2NamespacedHorizontalPodAutoscaler", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "autoscaling_v2" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "autoscaling", + "kind": "HorizontalPodAutoscaler", + "version": "v2" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the HorizontalPodAutoscaler", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_batch_v1.json b/gen/openapi_v1/specs/apis_batch_v1.json new file mode 100644 index 00000000..2df1e472 --- /dev/null +++ b/gen/openapi_v1/specs/apis_batch_v1.json @@ -0,0 +1,9907 @@ +{ + "components": { + "schemas": { + "io.k8s.api.batch.v1.CronJob": { + "description": "CronJob represents the configuration of a single cron job.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of a cron job, including the schedule. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobStatus" + } + ], + "default": {}, + "description": "Current status of a cron job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.CronJobList": { + "description": "CronJobList is a collection of cron jobs.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CronJobs.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "CronJobList", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.CronJobSpec": { + "description": "CronJobSpec describes how the job execution will look like and when it will actually run.", + "properties": { + "concurrencyPolicy": { + "description": "Specifies how to treat concurrent executions of a Job. Valid values are:\n\n- \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \"Replace\": cancels currently running job and replaces it with a new one", + "type": "string" + }, + "failedJobsHistoryLimit": { + "description": "The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1.", + "format": "int32", + "type": "integer" + }, + "jobTemplate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec" + } + ], + "default": {}, + "description": "Specifies the job that will be created when executing a CronJob." + }, + "schedule": { + "default": "", + "description": "The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.", + "type": "string" + }, + "startingDeadlineSeconds": { + "description": "Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones.", + "format": "int64", + "type": "integer" + }, + "successfulJobsHistoryLimit": { + "description": "The number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3.", + "format": "int32", + "type": "integer" + }, + "suspend": { + "description": "This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false.", + "type": "boolean" + }, + "timeZone": { + "description": "The time zone name for the given schedule, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. If not specified, this will default to the time zone of the kube-controller-manager process. The set of valid time zone names and the time zone offset is loaded from the system-wide time zone database by the API server during CronJob validation and the controller manager during execution. If no system-wide time zone database can be found a bundled version of the database is used instead. If the time zone name becomes invalid during the lifetime of a CronJob or due to a change in host configuration, the controller will stop creating new new Jobs and will create a system event with the reason UnknownTimeZone. More information can be found in https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#time-zones", + "type": "string" + } + }, + "required": [ + "schedule", + "jobTemplate" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.CronJobStatus": { + "description": "CronJobStatus represents the current state of a cron job.", + "properties": { + "active": { + "description": "A list of pointers to currently running jobs.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "lastScheduleTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Information when was the last time the job was successfully scheduled." + }, + "lastSuccessfulTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Information when was the last time the job successfully completed." + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.Job": { + "description": "Job represents the configuration of a single job.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of a job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobStatus" + } + ], + "default": {}, + "description": "Current status of a job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "Job", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.JobCondition": { + "description": "JobCondition describes current state of a job.", + "properties": { + "lastProbeTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition was checked." + }, + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Last time the condition transit from one status to another." + }, + "message": { + "description": "Human readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "(brief) reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of job condition, Complete or Failed.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.JobList": { + "description": "JobList is a collection of jobs.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of Jobs.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "JobList", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.JobSpec": { + "description": "JobSpec describes how the job execution will look like.", + "properties": { + "activeDeadlineSeconds": { + "description": "Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again.", + "format": "int64", + "type": "integer" + }, + "backoffLimit": { + "description": "Specifies the number of retries before marking this job failed. Defaults to 6, unless backoffLimitPerIndex (only Indexed Job) is specified. When backoffLimitPerIndex is specified, backoffLimit defaults to 2147483647.", + "format": "int32", + "type": "integer" + }, + "backoffLimitPerIndex": { + "description": "Specifies the limit for the number of retries within an index before marking this index as failed. When enabled the number of failures per index is kept in the pod's batch.kubernetes.io/job-index-failure-count annotation. It can only be set when Job's completionMode=Indexed, and the Pod's restart policy is Never. The field is immutable.", + "format": "int32", + "type": "integer" + }, + "completionMode": { + "description": "completionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.\n\n`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other.\n\n`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `$(job-name)-$(index)-$(random-string)`, the Pod hostname takes the form `$(job-name)-$(index)`.\n\nMore completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, which is possible during upgrades due to version skew, the controller skips updates for the Job.", + "type": "string" + }, + "completions": { + "description": "Specifies the desired number of successfully finished pods the job should be run with. Setting to null means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "format": "int32", + "type": "integer" + }, + "managedBy": { + "description": "ManagedBy field indicates the controller that manages a Job. The k8s Job controller reconciles jobs which don't have this field at all or the field value is the reserved string `kubernetes.io/job-controller`, but skips reconciling Jobs with a custom value for this field. The value must be a valid domain-prefixed path (e.g. acme.io/foo) - all characters before the first \"/\" must be a valid subdomain as defined by RFC 1123. All characters trailing the first \"/\" must be valid HTTP Path characters as defined by RFC 3986. The value cannot exceed 63 characters. This field is immutable.", + "type": "string" + }, + "manualSelector": { + "description": "manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector", + "type": "boolean" + }, + "maxFailedIndexes": { + "description": "Specifies the maximal number of failed indexes before marking the Job as failed, when backoffLimitPerIndex is set. Once the number of failed indexes exceeds this number the entire Job is marked as Failed and its execution is terminated. When left as null the job continues execution of all of its indexes and is marked with the `Complete` Job condition. It can only be specified when backoffLimitPerIndex is set. It can be null or up to completions. It is required and must be less than or equal to 10^4 when is completions greater than 10^5.", + "format": "int32", + "type": "integer" + }, + "parallelism": { + "description": "Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "format": "int32", + "type": "integer" + }, + "podFailurePolicy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy" + } + ], + "description": "Specifies the policy of handling failed pods. In particular, it allows to specify the set of actions and conditions which need to be satisfied to take the associated action. If empty, the default behaviour applies - the counter of failed pods, represented by the jobs's .status.failed field, is incremented and it is checked against the backoffLimit. This field cannot be used in combination with restartPolicy=OnFailure." + }, + "podReplacementPolicy": { + "description": "podReplacementPolicy specifies when to create replacement Pods. Possible values are: - TerminatingOrFailed means that we recreate pods\n when they are terminating (has a metadata.deletionTimestamp) or failed.\n- Failed means to wait until a previously created Pod is fully terminated (has phase\n Failed or Succeeded) before creating a replacement Pod.\n\nWhen using podFailurePolicy, Failed is the the only allowed value. TerminatingOrFailed and Failed are allowed values when podFailurePolicy is not in use.", + "type": "string" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over pods that should match the pod count. Normally, the system sets this field for you. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors" + }, + "successPolicy": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.SuccessPolicy" + } + ], + "description": "successPolicy specifies the policy when the Job can be declared as succeeded. If empty, the default behavior applies - the Job is declared as succeeded only when the number of succeeded pods equals to the completions. When the field is specified, it must be immutable and works only for the Indexed Jobs. Once the Job meets the SuccessPolicy, the lingering pods are terminated." + }, + "suspend": { + "description": "suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false.", + "type": "boolean" + }, + "template": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + } + ], + "default": {}, + "description": "Describes the pod that will be created when executing a job. The only allowed template.spec.restartPolicy values are \"Never\" or \"OnFailure\". More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/" + }, + "ttlSecondsAfterFinished": { + "description": "ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "template" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.JobStatus": { + "description": "JobStatus represents the current state of a Job.", + "properties": { + "active": { + "description": "The number of pending and running pods which are not terminating (without a deletionTimestamp). The value is zero for finished jobs.", + "format": "int32", + "type": "integer" + }, + "completedIndexes": { + "description": "completedIndexes holds the completed indexes when .spec.completionMode = \"Indexed\" in a text format. The indexes are represented as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\".", + "type": "string" + }, + "completionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Represents time when the job was completed. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC. The completion time is set when the job finishes successfully, and only then. The value cannot be updated or removed. The value indicates the same or later point in time as the startTime field." + }, + "conditions": { + "description": "The latest available observations of an object's current state. When a Job fails, one of the conditions will have type \"Failed\" and status true. When a Job is suspended, one of the conditions will have type \"Suspended\" and status true; when the Job is resumed, the status of this condition will become false. When a Job is completed, one of the conditions will have type \"Complete\" and status true.\n\nA job is considered finished when it is in a terminal condition, either \"Complete\" or \"Failed\". A Job cannot have both the \"Complete\" and \"Failed\" conditions. Additionally, it cannot be in the \"Complete\" and \"FailureTarget\" conditions. The \"Complete\", \"Failed\" and \"FailureTarget\" conditions cannot be disabled.\n\nMore info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "failed": { + "description": "The number of pods which reached phase Failed. The value increases monotonically.", + "format": "int32", + "type": "integer" + }, + "failedIndexes": { + "description": "FailedIndexes holds the failed indexes when spec.backoffLimitPerIndex is set. The indexes are represented in the text format analogous as for the `completedIndexes` field, ie. they are kept as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the failed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". The set of failed indexes cannot overlap with the set of completed indexes.", + "type": "string" + }, + "ready": { + "description": "The number of active pods which have a Ready condition and are not terminating (without a deletionTimestamp).", + "format": "int32", + "type": "integer" + }, + "startTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Represents time when the job controller started processing a job. When a Job is created in the suspended state, this field is not set until the first time it is resumed. This field is reset every time a Job is resumed from suspension. It is represented in RFC3339 form and is in UTC.\n\nOnce set, the field can only be removed when the job is suspended. The field cannot be modified while the job is unsuspended or finished." + }, + "succeeded": { + "description": "The number of pods which reached phase Succeeded. The value increases monotonically for a given spec. However, it may decrease in reaction to scale down of elastic indexed jobs.", + "format": "int32", + "type": "integer" + }, + "terminating": { + "description": "The number of pods which are terminating (in phase Pending or Running and have a deletionTimestamp).\n\nThis field is beta-level. The job controller populates the field when the feature gate JobPodReplacementPolicy is enabled (enabled by default).", + "format": "int32", + "type": "integer" + }, + "uncountedTerminatedPods": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods" + } + ], + "description": "uncountedTerminatedPods holds the UIDs of Pods that have terminated but the job controller hasn't yet accounted for in the status counters.\n\nThe job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status:\n\n1. Add the pod UID to the arrays in this field. 2. Remove the pod finalizer. 3. Remove the pod UID from the arrays while increasing the corresponding\n counter.\n\nOld jobs might not be tracked using this field, in which case the field remains null. The structure is empty for finished jobs." + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.JobTemplateSpec": { + "description": "JobTemplateSpec describes the data a Job should have when created from a template", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicy": { + "description": "PodFailurePolicy describes how failed pods influence the backoffLimit.", + "properties": { + "rules": { + "description": "A list of pod failure policy rules. The rules are evaluated in order. Once a rule matches a Pod failure, the remaining of the rules are ignored. When no rule matches the Pod failure, the default handling applies - the counter of pod failures is incremented and it is checked against the backoffLimit. At most 20 elements are allowed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "rules" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement": { + "description": "PodFailurePolicyOnExitCodesRequirement describes the requirement for handling a failed pod based on its container exit codes. In particular, it lookups the .state.terminated.exitCode for each app container and init container status, represented by the .status.containerStatuses and .status.initContainerStatuses fields in the Pod status, respectively. Containers completed with success (exit code 0) are excluded from the requirement check.", + "properties": { + "containerName": { + "description": "Restricts the check for exit codes to the container with the specified name. When null, the rule applies to all containers. When specified, it should match one the container or initContainer names in the pod template.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents the relationship between the container exit code(s) and the specified values. Containers completed with success (exit code 0) are excluded from the requirement check. Possible values are:\n\n- In: the requirement is satisfied if at least one container exit code\n (might be multiple if there are multiple containers not restricted\n by the 'containerName' field) is in the set of specified values.\n- NotIn: the requirement is satisfied if at least one container exit code\n (might be multiple if there are multiple containers not restricted\n by the 'containerName' field) is not in the set of specified values.\nAdditional values are considered to be added in the future. Clients should react to an unknown operator by assuming the requirement is not satisfied.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values. Each returned container exit code (might be multiple in case of multiple containers) is checked against this set of values with respect to the operator. The list of values must be ordered and must not contain duplicates. Value '0' cannot be used for the In operator. At least one element is required. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator", + "values" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern": { + "description": "PodFailurePolicyOnPodConditionsPattern describes a pattern for matching an actual pod condition type.", + "properties": { + "status": { + "default": "", + "description": "Specifies the required Pod condition status. To match a pod condition it is required that the specified status equals the pod condition status. Defaults to True.", + "type": "string" + }, + "type": { + "default": "", + "description": "Specifies the required Pod condition type. To match a pod condition it is required that specified type equals the pod condition type.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyRule": { + "description": "PodFailurePolicyRule describes how a pod failure is handled when the requirements are met. One of onExitCodes and onPodConditions, but not both, can be used in each rule.", + "properties": { + "action": { + "default": "", + "description": "Specifies the action taken on a pod failure when the requirements are satisfied. Possible values are:\n\n- FailJob: indicates that the pod's job is marked as Failed and all\n running pods are terminated.\n- FailIndex: indicates that the pod's index is marked as Failed and will\n not be restarted.\n- Ignore: indicates that the counter towards the .backoffLimit is not\n incremented and a replacement pod is created.\n- Count: indicates that the pod is handled in the default way - the\n counter towards the .backoffLimit is incremented.\nAdditional values are considered to be added in the future. Clients should react to an unknown action by skipping the rule.", + "type": "string" + }, + "onExitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement" + } + ], + "description": "Represents the requirement on the container exit codes." + }, + "onPodConditions": { + "description": "Represents the requirement on the pod conditions. The requirement is represented as a list of pod condition patterns. The requirement is satisfied if at least one pattern matches an actual pod condition. At most 20 elements are allowed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.SuccessPolicy": { + "description": "SuccessPolicy describes when a Job can be declared as succeeded based on the success of some indexes.", + "properties": { + "rules": { + "description": "rules represents the list of alternative rules for the declaring the Jobs as successful before `.status.succeeded >= .spec.completions`. Once any of the rules are met, the \"SuccessCriteriaMet\" condition is added, and the lingering pods are removed. The terminal state for such a Job has the \"Complete\" condition. Additionally, these rules are evaluated in order; Once the Job meets one of the rules, other rules are ignored. At most 20 elements are allowed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "rules" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.SuccessPolicyRule": { + "description": "SuccessPolicyRule describes rule for declaring a Job as succeeded. Each rule must have at least one of the \"succeededIndexes\" or \"succeededCount\" specified.", + "properties": { + "succeededCount": { + "description": "succeededCount specifies the minimal required size of the actual set of the succeeded indexes for the Job. When succeededCount is used along with succeededIndexes, the check is constrained only to the set of indexes specified by succeededIndexes. For example, given that succeededIndexes is \"1-4\", succeededCount is \"3\", and completed indexes are \"1\", \"3\", and \"5\", the Job isn't declared as succeeded because only \"1\" and \"3\" indexes are considered in that rules. When this field is null, this doesn't default to any value and is never evaluated at any time. When specified it needs to be a positive integer.", + "format": "int32", + "type": "integer" + }, + "succeededIndexes": { + "description": "succeededIndexes specifies the set of indexes which need to be contained in the actual set of the succeeded indexes for the Job. The list of indexes must be within 0 to \".spec.completions-1\" and must not contain duplicates. At least one element is required. The indexes are represented as intervals separated by commas. The intervals can be a decimal integer or a pair of decimal integers separated by a hyphen. The number are listed in represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". When this field is null, this field doesn't default to any value and is never evaluated at any time.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.UncountedTerminatedPods": { + "description": "UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters.", + "properties": { + "failed": { + "description": "failed holds UIDs of failed Pods.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set" + }, + "succeeded": { + "description": "succeeded holds UIDs of succeeded Pods.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + } + ], + "description": "Describes node affinity scheduling rules for the pod." + }, + "podAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + } + ], + "description": "Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s))." + }, + "podAntiAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + ], + "description": "Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s))." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed." + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is optional: points to a secret object containing parameters used to connect to OpenStack." + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Select all ClusterTrustBundles that match this label selector. Only has effect if signerName is set. Mutually-exclusive with name. If unset, interpreted as \"match nothing\". If set but empty, interpreted as \"match everything\"." + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Actions that the management system should take in response to container lifecycle events. Cannot be updated." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/" + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported." + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported." + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + } + ], + "description": "The ConfigMap to select from" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + ], + "description": "The Secret to select from" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + ], + "description": "Source for the environment variable's value. Cannot be used if value is not empty." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + } + ], + "description": "Selects a key of a ConfigMap." + }, + "fieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + } + ], + "description": "Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs." + }, + "fileKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + } + ], + "description": "FileKeyRef selects a key of the env file. Requires the EnvFiles feature gate to be enabled." + }, + "resourceFieldRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + ], + "description": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported." + }, + "secretKeyRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + ], + "description": "Selects a key of a secret in the pod's namespace" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + } + ], + "description": "Lifecycle is not allowed for ephemeral containers." + }, + "livenessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge" + }, + "readinessProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "default": {}, + "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + } + ], + "description": "Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext." + }, + "startupProbe": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + } + ], + "description": "Probes are not allowed for ephemeral containers." + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge" + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge" + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + ], + "description": "Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts." + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is the CHAP Secret for iSCSI target and initiator authentication" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "preStop": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + } + ], + "description": "PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "sleep": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + } + ], + "description": "Sleep represents a duration that the container should sleep." + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for backward compatibility. There is no validation of this field and lifecycle hooks will fail at runtime when it is specified." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + ], + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "dataSource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + } + ], + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." + }, + "dataSourceRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + } + ], + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + } + ], + "default": {}, + "description": "resources represents the minimum resources the volume should have. Users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources" + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "selector is a label query over volumes to consider for binding." + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + ], + "default": {}, + "description": "The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here." + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "namespaceSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces." + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows." + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + } + ], + "description": "If specified, the pod's scheduling constraints" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "dnsConfig": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + } + ], + "description": "Specifies the DNS parameters of a pod. Parameters specified here will be merged to the generated DNS configuration based on DNSPolicy." + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge" + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + } + ], + "description": "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.\n\nIf the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions\n\nIf the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.hostUsers - spec.resources - spec.securityContext.appArmorProfile - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.securityContext.supplementalGroupsPolicy - spec.containers[*].securityContext.appArmorProfile - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "resources": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + } + ], + "description": "Resources is the total amount of CPU and Memory resources required by all containers in the pod. It supports specifying Requests and Limits for \"cpu\", \"memory\" and \"hugepages-\" resource names only. ResourceClaims are not supported.\n\nThis field enables fine-grained control over resource allocation for the entire pod, allowing resource sharing among containers in a pod.\n\nThis is an alpha field and requires enabling the PodLevelResources feature gate." + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, + "securityContext": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + } + ], + "description": "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field." + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge" + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys" + }, + "workloadRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + ], + "description": "WorkloadRef provides a reference to the Workload object that this Pod belongs to. This field is used by the scheduler to identify the PodGroup and apply the correct group scheduling policies. The Workload object referenced by this field may not exist at the time the Pod is created. This field is immutable, but a Workload object with the same name may be recreated with different policies. Doing this during pod scheduling may result in the placement not conforming to the expected policies." + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {}, + "description": "A node selector term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + } + ], + "description": "Exec specifies a command to execute in the container." + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + } + ], + "description": "GRPC specifies a GRPC HealthCheckRequest." + }, + "httpGet": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + } + ], + "description": "HTTPGet specifies an HTTP GET request to perform." + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + ], + "description": "TCPSocket specifies a connection to a TCP port." + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "Specifies the output format of the exposed resources, defaults to \"1\"" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map" + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail." + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + } + ], + "description": "appArmorProfile is the AppArmor options to use by this container. If set, this profile overrides the pod's appArmorProfile. Note that this field cannot be set when spec.os.name is windows." + }, + "capabilities": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + } + ], + "description": "The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows." + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + } + ], + "description": "The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows." + }, + "seccompProfile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + } + ], + "description": "The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows." + }, + "windowsOptions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + ], + "description": "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + ], + "description": "secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted." + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME." + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + } + ], + "description": "awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore" + }, + "azureDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + } + ], + "description": "azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver." + }, + "azureFile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + } + ], + "description": "azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver." + }, + "cephfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + } + ], + "description": "cephFS represents a Ceph FS mount on the host that shares a pod's lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported." + }, + "cinder": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + } + ], + "description": "cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: https://examples.k8s.io/mysql-cinder-pd/README.md" + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + } + ], + "description": "configMap represents a configMap that should populate this volume" + }, + "csi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + } + ], + "description": "csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers." + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + } + ], + "description": "downwardAPI represents downward API about the pod that should populate this volume" + }, + "emptyDir": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + } + ], + "description": "emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir" + }, + "ephemeral": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + } + ], + "description": "ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time." + }, + "fc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + } + ], + "description": "fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod." + }, + "flexVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + } + ], + "description": "flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead." + }, + "flocker": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + } + ], + "description": "flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported." + }, + "gcePersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + } + ], + "description": "gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk" + }, + "gitRepo": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + } + ], + "description": "gitRepo represents a git repository at a particular revision. Deprecated: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container." + }, + "glusterfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + } + ], + "description": "glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported." + }, + "hostPath": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + } + ], + "description": "hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath" + }, + "image": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + } + ], + "description": "image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet's host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided:\n\n- Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.\n\nThe volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type." + }, + "iscsi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + } + ], + "description": "iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes/#iscsi" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + } + ], + "description": "nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs" + }, + "persistentVolumeClaim": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + } + ], + "description": "persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims" + }, + "photonPersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + } + ], + "description": "photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported." + }, + "portworxVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + } + ], + "description": "portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver when the CSIMigrationPortworx feature-gate is on." + }, + "projected": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + } + ], + "description": "projected items for all in one resources secrets, configmaps, and downward API" + }, + "quobyte": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + } + ], + "description": "quobyte represents a Quobyte mount on the host that shares a pod's lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported." + }, + "rbd": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + } + ], + "description": "rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported." + }, + "scaleIO": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + } + ], + "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + } + ], + "description": "secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret" + }, + "storageos": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + } + ], + "description": "storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported." + }, + "vsphereVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + ], + "description": "vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + } + ], + "description": "ClusterTrustBundle allows a pod to access the `.spec.trustBundle` field of ClusterTrustBundle objects in an auto-updating file.\n\nAlpha, gated by the ClusterTrustBundleProjection feature gate.\n\nClusterTrustBundle objects can either be selected by name, or by the combination of signer name and a label selector.\n\nKubelet performs aggressive normalization of the PEM contents written into the pod filesystem. Esoteric PEM features such as inter-block comments and block headers are stripped. Certificates are deduplicated. The ordering of certificates within the file is arbitrary, and Kubelet may change the order over time." + }, + "configMap": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + } + ], + "description": "configMap information about the configMap data to project" + }, + "downwardAPI": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + } + ], + "description": "downwardAPI information about the downwardAPI data to project" + }, + "podCertificate": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + } + ], + "description": "Projects an auto-rotating credential bundle (private key and certificate chain) that the pod can use either as a TLS client or server.\n\nKubelet generates a private key and uses it to send a PodCertificateRequest to the named signer. Once the signer approves the request and issues a certificate chain, Kubelet writes the key and certificate chain to the pod filesystem. The pod does not start until certificates have been issued for each podCertificate projected volume source in its spec.\n\nKubelet will begin trying to rotate the certificate at the time indicated by the signer using the PodCertificateRequest.Status.BeginRefreshAt timestamp.\n\nKubelet can write a single file, indicated by the credentialBundlePath field, or separate files, indicated by the keyPath and certificateChainPath fields.\n\nThe credential bundle is a single file in PEM format. The first PEM entry is the private key (in PKCS#8 format), and the remaining PEM entries are the certificate chain issued by the signer (typically, signers will return their certificate chain in leaf-to-root order).\n\nPrefer using the credential bundle format, since your application code can read it atomically. If you use keyPath and certificateChainPath, your application must make two separate file reads. If these coincide with a certificate rotation, it is possible that the private key and leaf certificate you read may not correspond to each other. Your application will need to check for this condition, and re-read until they are consistent.\n\nThe named signer controls chooses the format of the certificate it issues; consult the signer implementation's documentation to learn how to use the certificates it issues." + }, + "secret": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + } + ], + "description": "secret information about the secret data to project" + }, + "serviceAccountToken": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + ], + "description": "serviceAccountToken is information about the serviceAccountToken data to project" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + } + ], + "default": {}, + "description": "Required. A pod affinity term, associated with the corresponding weight." + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/batch/v1/": { + "get": { + "description": "get available resources", + "operationId": "getBatchV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ] + } + }, + "/apis/batch/v1/cronjobs": { + "get": { + "description": "list or watch objects of kind CronJob", + "operationId": "listBatchV1CronJobForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/jobs": { + "get": { + "description": "list or watch objects of kind Job", + "operationId": "listBatchV1JobForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs": { + "delete": { + "description": "delete collection of CronJob", + "operationId": "deleteBatchV1CollectionNamespacedCronJob", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CronJob", + "operationId": "listBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CronJob", + "operationId": "createBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}": { + "delete": { + "description": "delete a CronJob", + "operationId": "deleteBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "get": { + "description": "read the specified CronJob", + "operationId": "readBatchV1NamespacedCronJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CronJob", + "operationId": "patchBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CronJob", + "operationId": "replaceBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status": { + "get": { + "description": "read status of the specified CronJob", + "operationId": "readBatchV1NamespacedCronJobStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CronJob", + "operationId": "patchBatchV1NamespacedCronJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CronJob", + "operationId": "replaceBatchV1NamespacedCronJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs": { + "delete": { + "description": "delete collection of Job", + "operationId": "deleteBatchV1CollectionNamespacedJob", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Job", + "operationId": "listBatchV1NamespacedJob", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Job", + "operationId": "createBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs/{name}": { + "delete": { + "description": "delete a Job", + "operationId": "deleteBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "get": { + "description": "read the specified Job", + "operationId": "readBatchV1NamespacedJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Job", + "operationId": "patchBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Job", + "operationId": "replaceBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status": { + "get": { + "description": "read status of the specified Job", + "operationId": "readBatchV1NamespacedJobStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Job", + "operationId": "patchBatchV1NamespacedJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Job", + "operationId": "replaceBatchV1NamespacedJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/watch/cronjobs": { + "get": { + "description": "watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1CronJobListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/jobs": { + "get": { + "description": "watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1JobListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs": { + "get": { + "description": "watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1NamespacedCronJobList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}": { + "get": { + "description": "watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchBatchV1NamespacedCronJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/jobs": { + "get": { + "description": "watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1NamespacedJobList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}": { + "get": { + "description": "watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchBatchV1NamespacedJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_batch_v1_patched.json b/gen/openapi_v1/specs/apis_batch_v1_patched.json new file mode 100644 index 00000000..0b3fbf79 --- /dev/null +++ b/gen/openapi_v1/specs/apis_batch_v1_patched.json @@ -0,0 +1,8967 @@ +{ + "components": { + "schemas": { + "io.k8s.api.batch.v1.CronJob": { + "description": "CronJob represents the configuration of a single cron job.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.CronJobList": { + "description": "CronJobList is a collection of cron jobs.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CronJobs.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "CronJobList", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.CronJobSpec": { + "description": "CronJobSpec describes how the job execution will look like and when it will actually run.", + "properties": { + "concurrencyPolicy": { + "description": "Specifies how to treat concurrent executions of a Job. Valid values are:\n\n- \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \"Replace\": cancels currently running job and replaces it with a new one", + "type": "string" + }, + "failedJobsHistoryLimit": { + "description": "The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1.", + "format": "int32", + "type": "integer" + }, + "jobTemplate": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec" + }, + "schedule": { + "default": "", + "description": "The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.", + "type": "string" + }, + "startingDeadlineSeconds": { + "description": "Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones.", + "format": "int64", + "type": "integer" + }, + "successfulJobsHistoryLimit": { + "description": "The number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3.", + "format": "int32", + "type": "integer" + }, + "suspend": { + "description": "This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false.", + "type": "boolean" + }, + "timeZone": { + "description": "The time zone name for the given schedule, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. If not specified, this will default to the time zone of the kube-controller-manager process. The set of valid time zone names and the time zone offset is loaded from the system-wide time zone database by the API server during CronJob validation and the controller manager during execution. If no system-wide time zone database can be found a bundled version of the database is used instead. If the time zone name becomes invalid during the lifetime of a CronJob or due to a change in host configuration, the controller will stop creating new new Jobs and will create a system event with the reason UnknownTimeZone. More information can be found in https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#time-zones", + "type": "string" + } + }, + "required": [ + "schedule", + "jobTemplate" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.CronJobStatus": { + "description": "CronJobStatus represents the current state of a cron job.", + "properties": { + "active": { + "description": "A list of pointers to currently running jobs.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "lastScheduleTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastSuccessfulTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.Job": { + "description": "Job represents the configuration of a single job.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "Job", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.JobCondition": { + "description": "JobCondition describes current state of a job.", + "properties": { + "lastProbeTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "Human readable message indicating details about last transition.", + "type": "string" + }, + "reason": { + "description": "(brief) reason for the condition's last transition.", + "type": "string" + }, + "status": { + "default": "", + "description": "Status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "Type of job condition, Complete or Failed.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.JobList": { + "description": "JobList is a collection of jobs.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of Jobs.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "batch", + "kind": "JobList", + "version": "v1" + } + ] + }, + "io.k8s.api.batch.v1.JobSpec": { + "description": "JobSpec describes how the job execution will look like.", + "properties": { + "activeDeadlineSeconds": { + "description": "Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again.", + "format": "int64", + "type": "integer" + }, + "backoffLimit": { + "description": "Specifies the number of retries before marking this job failed. Defaults to 6, unless backoffLimitPerIndex (only Indexed Job) is specified. When backoffLimitPerIndex is specified, backoffLimit defaults to 2147483647.", + "format": "int32", + "type": "integer" + }, + "backoffLimitPerIndex": { + "description": "Specifies the limit for the number of retries within an index before marking this index as failed. When enabled the number of failures per index is kept in the pod's batch.kubernetes.io/job-index-failure-count annotation. It can only be set when Job's completionMode=Indexed, and the Pod's restart policy is Never. The field is immutable.", + "format": "int32", + "type": "integer" + }, + "completionMode": { + "description": "completionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.\n\n`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other.\n\n`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `$(job-name)-$(index)-$(random-string)`, the Pod hostname takes the form `$(job-name)-$(index)`.\n\nMore completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, which is possible during upgrades due to version skew, the controller skips updates for the Job.", + "type": "string" + }, + "completions": { + "description": "Specifies the desired number of successfully finished pods the job should be run with. Setting to null means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "format": "int32", + "type": "integer" + }, + "managedBy": { + "description": "ManagedBy field indicates the controller that manages a Job. The k8s Job controller reconciles jobs which don't have this field at all or the field value is the reserved string `kubernetes.io/job-controller`, but skips reconciling Jobs with a custom value for this field. The value must be a valid domain-prefixed path (e.g. acme.io/foo) - all characters before the first \"/\" must be a valid subdomain as defined by RFC 1123. All characters trailing the first \"/\" must be valid HTTP Path characters as defined by RFC 3986. The value cannot exceed 63 characters. This field is immutable.", + "type": "string" + }, + "manualSelector": { + "description": "manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector", + "type": "boolean" + }, + "maxFailedIndexes": { + "description": "Specifies the maximal number of failed indexes before marking the Job as failed, when backoffLimitPerIndex is set. Once the number of failed indexes exceeds this number the entire Job is marked as Failed and its execution is terminated. When left as null the job continues execution of all of its indexes and is marked with the `Complete` Job condition. It can only be specified when backoffLimitPerIndex is set. It can be null or up to completions. It is required and must be less than or equal to 10^4 when is completions greater than 10^5.", + "format": "int32", + "type": "integer" + }, + "parallelism": { + "description": "Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "format": "int32", + "type": "integer" + }, + "podFailurePolicy": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy" + }, + "podReplacementPolicy": { + "description": "podReplacementPolicy specifies when to create replacement Pods. Possible values are: - TerminatingOrFailed means that we recreate pods\n when they are terminating (has a metadata.deletionTimestamp) or failed.\n- Failed means to wait until a previously created Pod is fully terminated (has phase\n Failed or Succeeded) before creating a replacement Pod.\n\nWhen using podFailurePolicy, Failed is the the only allowed value. TerminatingOrFailed and Failed are allowed values when podFailurePolicy is not in use.", + "type": "string" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "successPolicy": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.SuccessPolicy" + }, + "suspend": { + "description": "suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false.", + "type": "boolean" + }, + "template": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec" + }, + "ttlSecondsAfterFinished": { + "description": "ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "template" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.JobStatus": { + "description": "JobStatus represents the current state of a Job.", + "properties": { + "active": { + "description": "The number of pending and running pods which are not terminating (without a deletionTimestamp). The value is zero for finished jobs.", + "format": "int32", + "type": "integer" + }, + "completedIndexes": { + "description": "completedIndexes holds the completed indexes when .spec.completionMode = \"Indexed\" in a text format. The indexes are represented as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\".", + "type": "string" + }, + "completionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "conditions": { + "description": "The latest available observations of an object's current state. When a Job fails, one of the conditions will have type \"Failed\" and status true. When a Job is suspended, one of the conditions will have type \"Suspended\" and status true; when the Job is resumed, the status of this condition will become false. When a Job is completed, one of the conditions will have type \"Complete\" and status true.\n\nA job is considered finished when it is in a terminal condition, either \"Complete\" or \"Failed\". A Job cannot have both the \"Complete\" and \"Failed\" conditions. Additionally, it cannot be in the \"Complete\" and \"FailureTarget\" conditions. The \"Complete\", \"Failed\" and \"FailureTarget\" conditions cannot be disabled.\n\nMore info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobCondition" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "failed": { + "description": "The number of pods which reached phase Failed. The value increases monotonically.", + "format": "int32", + "type": "integer" + }, + "failedIndexes": { + "description": "FailedIndexes holds the failed indexes when spec.backoffLimitPerIndex is set. The indexes are represented in the text format analogous as for the `completedIndexes` field, ie. they are kept as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the failed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". The set of failed indexes cannot overlap with the set of completed indexes.", + "type": "string" + }, + "ready": { + "description": "The number of active pods which have a Ready condition and are not terminating (without a deletionTimestamp).", + "format": "int32", + "type": "integer" + }, + "startTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "succeeded": { + "description": "The number of pods which reached phase Succeeded. The value increases monotonically for a given spec. However, it may decrease in reaction to scale down of elastic indexed jobs.", + "format": "int32", + "type": "integer" + }, + "terminating": { + "description": "The number of pods which are terminating (in phase Pending or Running and have a deletionTimestamp).\n\nThis field is beta-level. The job controller populates the field when the feature gate JobPodReplacementPolicy is enabled (enabled by default).", + "format": "int32", + "type": "integer" + }, + "uncountedTerminatedPods": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.JobTemplateSpec": { + "description": "JobTemplateSpec describes the data a Job should have when created from a template", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobSpec" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicy": { + "description": "PodFailurePolicy describes how failed pods influence the backoffLimit.", + "properties": { + "rules": { + "description": "A list of pod failure policy rules. The rules are evaluated in order. Once a rule matches a Pod failure, the remaining of the rules are ignored. When no rule matches the Pod failure, the default handling applies - the counter of pod failures is incremented and it is checked against the backoffLimit. At most 20 elements are allowed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "rules" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement": { + "description": "PodFailurePolicyOnExitCodesRequirement describes the requirement for handling a failed pod based on its container exit codes. In particular, it lookups the .state.terminated.exitCode for each app container and init container status, represented by the .status.containerStatuses and .status.initContainerStatuses fields in the Pod status, respectively. Containers completed with success (exit code 0) are excluded from the requirement check.", + "properties": { + "containerName": { + "description": "Restricts the check for exit codes to the container with the specified name. When null, the rule applies to all containers. When specified, it should match one the container or initContainer names in the pod template.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents the relationship between the container exit code(s) and the specified values. Containers completed with success (exit code 0) are excluded from the requirement check. Possible values are:\n\n- In: the requirement is satisfied if at least one container exit code\n (might be multiple if there are multiple containers not restricted\n by the 'containerName' field) is in the set of specified values.\n- NotIn: the requirement is satisfied if at least one container exit code\n (might be multiple if there are multiple containers not restricted\n by the 'containerName' field) is not in the set of specified values.\nAdditional values are considered to be added in the future. Clients should react to an unknown operator by assuming the requirement is not satisfied.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values. Each returned container exit code (might be multiple in case of multiple containers) is checked against this set of values with respect to the operator. The list of values must be ordered and must not contain duplicates. Value '0' cannot be used for the In operator. At least one element is required. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "required": [ + "operator", + "values" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern": { + "description": "PodFailurePolicyOnPodConditionsPattern describes a pattern for matching an actual pod condition type.", + "properties": { + "status": { + "default": "", + "description": "Specifies the required Pod condition status. To match a pod condition it is required that the specified status equals the pod condition status. Defaults to True.", + "type": "string" + }, + "type": { + "default": "", + "description": "Specifies the required Pod condition type. To match a pod condition it is required that specified type equals the pod condition type.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.PodFailurePolicyRule": { + "description": "PodFailurePolicyRule describes how a pod failure is handled when the requirements are met. One of onExitCodes and onPodConditions, but not both, can be used in each rule.", + "properties": { + "action": { + "default": "", + "description": "Specifies the action taken on a pod failure when the requirements are satisfied. Possible values are:\n\n- FailJob: indicates that the pod's job is marked as Failed and all\n running pods are terminated.\n- FailIndex: indicates that the pod's index is marked as Failed and will\n not be restarted.\n- Ignore: indicates that the counter towards the .backoffLimit is not\n incremented and a replacement pod is created.\n- Count: indicates that the pod is handled in the default way - the\n counter towards the .backoffLimit is incremented.\nAdditional values are considered to be added in the future. Clients should react to an unknown action by skipping the rule.", + "type": "string" + }, + "onExitCodes": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement" + }, + "onPodConditions": { + "description": "Represents the requirement on the pod conditions. The requirement is represented as a list of pod condition patterns. The requirement is satisfied if at least one pattern matches an actual pod condition. At most 20 elements are allowed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.SuccessPolicy": { + "description": "SuccessPolicy describes when a Job can be declared as succeeded based on the success of some indexes.", + "properties": { + "rules": { + "description": "rules represents the list of alternative rules for the declaring the Jobs as successful before `.status.succeeded >= .spec.completions`. Once any of the rules are met, the \"SuccessCriteriaMet\" condition is added, and the lingering pods are removed. The terminal state for such a Job has the \"Complete\" condition. Additionally, these rules are evaluated in order; Once the Job meets one of the rules, other rules are ignored. At most 20 elements are allowed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "rules" + ], + "type": "object" + }, + "io.k8s.api.batch.v1.SuccessPolicyRule": { + "description": "SuccessPolicyRule describes rule for declaring a Job as succeeded. Each rule must have at least one of the \"succeededIndexes\" or \"succeededCount\" specified.", + "properties": { + "succeededCount": { + "description": "succeededCount specifies the minimal required size of the actual set of the succeeded indexes for the Job. When succeededCount is used along with succeededIndexes, the check is constrained only to the set of indexes specified by succeededIndexes. For example, given that succeededIndexes is \"1-4\", succeededCount is \"3\", and completed indexes are \"1\", \"3\", and \"5\", the Job isn't declared as succeeded because only \"1\" and \"3\" indexes are considered in that rules. When this field is null, this doesn't default to any value and is never evaluated at any time. When specified it needs to be a positive integer.", + "format": "int32", + "type": "integer" + }, + "succeededIndexes": { + "description": "succeededIndexes specifies the set of indexes which need to be contained in the actual set of the succeeded indexes for the Job. The list of indexes must be within 0 to \".spec.completions-1\" and must not contain duplicates. At least one element is required. The indexes are represented as intervals separated by commas. The intervals can be a decimal integer or a pair of decimal integers separated by a hyphen. The number are listed in represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\". When this field is null, this field doesn't default to any value and is never evaluated at any time.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.batch.v1.UncountedTerminatedPods": { + "description": "UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters.", + "properties": { + "failed": { + "description": "failed holds UIDs of failed Pods.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + }, + "succeeded": { + "description": "succeeded holds UIDs of succeeded Pods.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Affinity": { + "description": "Affinity is a group of affinity scheduling rules.", + "properties": { + "nodeAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeAffinity" + }, + "podAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinity" + }, + "podAntiAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.AppArmorProfile": { + "description": "AppArmorProfile defines a pod or container's AppArmor settings.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \"Localhost\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of AppArmor profile will be applied. Valid options are:\n Localhost - a profile pre-loaded on the node.\n RuntimeDefault - the container runtime's default profile.\n Unconfined - no AppArmor enforcement.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFileVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIVolumeSource": { + "description": "Represents a source location of a volume to mount, managed by an external CSI driver", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.", + "type": "string" + }, + "nodePublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "readOnly": { + "description": "readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.", + "type": "object" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Capabilities": { + "description": "Adds and removes POSIX capabilities from running containers.", + "properties": { + "add": { + "description": "Added capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "drop": { + "description": "Removed capabilities", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.CephFSVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "description": "user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ClusterTrustBundleProjection": { + "description": "ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "name": { + "description": "Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.", + "type": "string" + }, + "optional": { + "description": "If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "Relative path from the volume root to write the bundle.", + "type": "string" + }, + "signerName": { + "description": "Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapEnvSource": { + "description": "ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapKeySelector": { + "description": "Selects a key from a ConfigMap.", + "properties": { + "key": { + "default": "", + "description": "The key to select.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the ConfigMap or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ConfigMapProjection": { + "description": "Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ConfigMapVolumeSource": { + "description": "Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional specify whether the ConfigMap or its keys must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Container": { + "description": "A single application container that you want to run within a pod.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.", + "type": "string" + }, + "ports": { + "description": "List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container. This field cannot be set on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerPort": { + "description": "ContainerPort represents a network port in a single container.", + "properties": { + "containerPort": { + "default": 0, + "description": "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.", + "format": "int32", + "type": "integer" + }, + "hostIP": { + "description": "What host IP to bind the external port to.", + "type": "string" + }, + "hostPort": { + "description": "Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.", + "format": "int32", + "type": "integer" + }, + "name": { + "description": "If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.", + "type": "string" + }, + "protocol": { + "default": "TCP", + "description": "Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".", + "type": "string" + } + }, + "required": [ + "containerPort" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerResizePolicy": { + "description": "ContainerResizePolicy represents resource resize policy for the container.", + "properties": { + "resourceName": { + "default": "", + "description": "Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.", + "type": "string" + }, + "restartPolicy": { + "default": "", + "description": "Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.", + "type": "string" + } + }, + "required": [ + "resourceName", + "restartPolicy" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "required": [ + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIProjection": { + "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", + "properties": { + "items": { + "description": "Items is a list of DownwardAPIVolume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeFile": { + "description": "DownwardAPIVolumeFile represents information to create the file containing the pod field", + "properties": { + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "mode": { + "description": "Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'", + "type": "string" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.DownwardAPIVolumeSource": { + "description": "DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "Items is a list of downward API volume file", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EmptyDirVolumeSource": { + "description": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.", + "properties": { + "medium": { + "description": "medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir", + "type": "string" + }, + "sizeLimit": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvFromSource": { + "description": "EnvFromSource represents the source of a set of ConfigMaps or Secrets", + "properties": { + "configMapRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource" + }, + "prefix": { + "description": "Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretEnvSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EnvVar": { + "description": "EnvVar represents an environment variable present in a Container.", + "properties": { + "name": { + "default": "", + "description": "Name of the environment variable. May consist of any printable ASCII characters except '='.", + "type": "string" + }, + "value": { + "description": "Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".", + "type": "string" + }, + "valueFrom": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVarSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EnvVarSource": { + "description": "EnvVarSource represents a source for the value of an EnvVar.", + "properties": { + "configMapKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector" + }, + "fieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector" + }, + "fileKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FileKeySelector" + }, + "resourceFieldRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector" + }, + "secretKeyRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretKeySelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralContainer": { + "description": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.", + "properties": { + "args": { + "description": "Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "command": { + "description": "Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "env": { + "description": "List of environment variables to set in the container. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvVar" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "envFrom": { + "description": "List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EnvFromSource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "image": { + "description": "Container image name. More info: https://kubernetes.io/docs/concepts/containers/images", + "type": "string" + }, + "imagePullPolicy": { + "description": "Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images", + "type": "string" + }, + "lifecycle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Lifecycle" + }, + "livenessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "name": { + "default": "", + "description": "Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.", + "type": "string" + }, + "ports": { + "description": "Ports are not allowed for ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerPort" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "containerPort", + "protocol" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "containerPort", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "readinessProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "resizePolicy": { + "description": "Resources resize policy for the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "type": "string" + }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecurityContext" + }, + "startupProbe": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Probe" + }, + "stdin": { + "description": "Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.", + "type": "boolean" + }, + "stdinOnce": { + "description": "Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false", + "type": "boolean" + }, + "targetContainerName": { + "description": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", + "type": "string" + }, + "terminationMessagePath": { + "description": "Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.", + "type": "string" + }, + "terminationMessagePolicy": { + "description": "Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.", + "type": "string" + }, + "tty": { + "description": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.", + "type": "boolean" + }, + "volumeDevices": { + "description": "volumeDevices is the list of block devices to be used by the container.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeDevice" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "devicePath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "devicePath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumeMounts": { + "description": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeMount" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "mountPath" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "mountPath", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "workingDir": { + "description": "Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.EphemeralVolumeSource": { + "description": "Represents an ephemeral volume that is handled by a normal storage driver.", + "properties": { + "volumeClaimTemplate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ExecAction": { + "description": "ExecAction describes a \"run in container\" action.", + "properties": { + "command": { + "description": "Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FileKeySelector": { + "description": "FileKeySelector selects a key of the env file.", + "properties": { + "key": { + "default": "", + "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.", + "type": "string" + }, + "optional": { + "default": false, + "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.", + "type": "boolean" + }, + "path": { + "default": "", + "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.", + "type": "string" + }, + "volumeName": { + "default": "", + "description": "The name of the volume mount containing the env file.", + "type": "string" + } + }, + "required": [ + "volumeName", + "path", + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.FlexVolumeSource": { + "description": "FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GRPCAction": { + "description": "GRPCAction specifies an action involving a GRPC service.", + "properties": { + "port": { + "default": 0, + "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "format": "int32", + "type": "integer" + }, + "service": { + "default": "", + "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GitRepoVolumeSource": { + "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", + "properties": { + "directory": { + "description": "directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.", + "type": "string" + }, + "repository": { + "default": "", + "description": "repository is the URL", + "type": "string" + }, + "revision": { + "description": "revision is the commit hash for the specified revision.", + "type": "string" + } + }, + "required": [ + "repository" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology.", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPGetAction": { + "description": "HTTPGetAction describes an action based on HTTP Get requests.", + "properties": { + "host": { + "description": "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.", + "type": "string" + }, + "httpHeaders": { + "description": "Custom headers to set in the request. HTTP allows repeated headers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPHeader" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "Path to access on the HTTP server.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "scheme": { + "description": "Scheme to use for connecting to the host. Defaults to HTTP.", + "type": "string" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HTTPHeader": { + "description": "HTTPHeader describes a custom header to be used in HTTP probes", + "properties": { + "name": { + "default": "", + "description": "The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.", + "type": "string" + }, + "value": { + "default": "", + "description": "The header field value", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostAlias": { + "description": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", + "properties": { + "hostnames": { + "description": "Hostnames for the above IP address.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ip": { + "default": "", + "description": "IP address of the host file entry.", + "type": "string" + } + }, + "required": [ + "ip" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIVolumeSource": { + "description": "Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is the target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun represents iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ImageVolumeSource": { + "description": "ImageVolumeSource represents a image volume resource.", + "properties": { + "pullPolicy": { + "description": "Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.", + "type": "string" + }, + "reference": { + "description": "Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.KeyToPath": { + "description": "Maps a string key to a path within a volume.", + "properties": { + "key": { + "default": "", + "description": "key is the key to project.", + "type": "string" + }, + "mode": { + "description": "mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.", + "type": "string" + } + }, + "required": [ + "key", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Lifecycle": { + "description": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", + "properties": { + "postStart": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "preStop": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LifecycleHandler" + }, + "stopSignal": { + "description": "StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LifecycleHandler": { + "description": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "sleep": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SleepAction" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.LocalObjectReference": { + "description": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeAffinity": { + "description": "Node affinity is a group of node affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectFieldSelector": { + "description": "ObjectFieldSelector selects an APIVersioned field of an object.", + "properties": { + "apiVersion": { + "description": "Version of the schema the FieldPath is written in terms of, defaults to \"v1\".", + "type": "string" + }, + "fieldPath": { + "default": "", + "description": "Path of the field to select in the specified API version.", + "type": "string" + } + }, + "required": [ + "fieldPath" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimSpec": { + "description": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", + "properties": { + "accessModes": { + "description": "accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "dataSource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + }, + "dataSourceRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "storageClassName": { + "description": "storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", + "type": "string" + }, + "volumeAttributesClassName": { + "description": "volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the binding reference to the PersistentVolume backing this claim.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": { + "description": "PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec" + } + }, + "required": [ + "spec" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": { + "description": "PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).", + "properties": { + "claimName": { + "default": "", + "description": "claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims", + "type": "string" + }, + "readOnly": { + "description": "readOnly Will force the ReadOnly setting in VolumeMounts. Default false.", + "type": "boolean" + } + }, + "required": [ + "claimName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinity": { + "description": "Pod affinity is a group of inter pod affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodAffinityTerm": { + "description": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "namespaceSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "namespaces": { + "description": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologyKey": { + "default": "", + "description": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", + "type": "string" + } + }, + "required": [ + "topologyKey" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodAntiAffinity": { + "description": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.", + "properties": { + "preferredDuringSchedulingIgnoredDuringExecution": { + "description": "The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \"weight\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "requiredDuringSchedulingIgnoredDuringExecution": { + "description": "If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodCertificateProjection": { + "description": "PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.", + "properties": { + "certificateChainPath": { + "description": "Write the certificate chain at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "credentialBundlePath": { + "description": "Write the credential bundle at this path in the projected volume.\n\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\n\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\n\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.", + "type": "string" + }, + "keyPath": { + "description": "Write the key at this path in the projected volume.\n\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.", + "type": "string" + }, + "keyType": { + "description": "The type of keypair Kubelet will generate for the pod.\n\nValid values are \"RSA3072\", \"RSA4096\", \"ECDSAP256\", \"ECDSAP384\", \"ECDSAP521\", and \"ED25519\".", + "type": "string" + }, + "maxExpirationSeconds": { + "description": "maxExpirationSeconds is the maximum lifetime permitted for the certificate.\n\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\n\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\n\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.", + "format": "int32", + "type": "integer" + }, + "signerName": { + "description": "Kubelet's generated CSRs will be addressed to this signer.", + "type": "string" + }, + "userAnnotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\n\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\n\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\n\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.", + "type": "object" + } + }, + "required": [ + "signerName", + "keyType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfig": { + "description": "PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.", + "properties": { + "nameservers": { + "description": "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "options": { + "description": "A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "searches": { + "description": "A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodDNSConfigOption": { + "description": "PodDNSConfigOption defines DNS resolver options of a pod.", + "properties": { + "name": { + "description": "Name is this DNS resolver option's name. Required.", + "type": "string" + }, + "value": { + "description": "Value is this DNS resolver option's value.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodOS": { + "description": "PodOS defines the OS parameters of a pod.", + "properties": { + "name": { + "default": "", + "description": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodReadinessGate": { + "description": "PodReadinessGate contains the reference to a pod condition", + "properties": { + "conditionType": { + "default": "", + "description": "ConditionType refers to a condition in the pod's condition list with matching type.", + "type": "string" + } + }, + "required": [ + "conditionType" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodResourceClaim": { + "description": "PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\n\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.", + "properties": { + "name": { + "default": "", + "description": "Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.", + "type": "string" + }, + "resourceClaimName": { + "description": "ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + }, + "resourceClaimTemplateName": { + "description": "ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\n\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\n\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\n\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodSecurityContext": { + "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", + "properties": { + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "fsGroup": { + "description": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\n\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "fsGroupChangePolicy": { + "description": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxChangePolicy": { + "description": "seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \"MountOption\" and \"Recursive\".\n\n\"Recursive\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\n\n\"MountOption\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \"MountOption\" value is allowed only when SELinuxMount feature gate is enabled.\n\nIf not specified and SELinuxMount feature gate is enabled, \"MountOption\" is used. If not specified and SELinuxMount feature gate is disabled, \"MountOption\" is used for ReadWriteOncePod volumes and \"Recursive\" for all other volumes.\n\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\n\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "supplementalGroups": { + "description": "A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "default": 0, + "format": "int64", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "supplementalGroupsPolicy": { + "description": "Defines how supplemental groups of the first container processes are calculated. Valid values are \"Merge\" and \"Strict\". If not specified, \"Merge\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "sysctls": { + "description": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Sysctl" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PodSpec": { + "description": "PodSpec is a description of a pod.", + "properties": { + "activeDeadlineSeconds": { + "description": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", + "format": "int64", + "type": "integer" + }, + "affinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Affinity" + }, + "automountServiceAccountToken": { + "description": "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.", + "type": "boolean" + }, + "containers": { + "description": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "dnsConfig": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodDNSConfig" + }, + "dnsPolicy": { + "description": "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.", + "type": "string" + }, + "enableServiceLinks": { + "description": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "type": "boolean" + }, + "ephemeralContainers": { + "description": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralContainer" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostAliases": { + "description": "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostAlias" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "ip" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "ip", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "hostIPC": { + "description": "Use the host's ipc namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostNetwork": { + "description": "Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.", + "type": "boolean" + }, + "hostPID": { + "description": "Use the host's pid namespace. Optional: Default to false.", + "type": "boolean" + }, + "hostUsers": { + "description": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "type": "boolean" + }, + "hostname": { + "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", + "type": "string" + }, + "hostnameOverride": { + "description": "HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\n\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.", + "type": "string" + }, + "imagePullSecrets": { + "description": "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "initContainers": { + "description": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Container" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "nodeName": { + "description": "NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename", + "type": "string" + }, + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "os": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" + }, + "overhead": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", + "type": "object" + }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "priority": { + "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", + "format": "int32", + "type": "integer" + }, + "priorityClassName": { + "description": "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.", + "type": "string" + }, + "readinessGates": { + "description": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodReadinessGate" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resourceClaims": { + "description": "ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\n\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\n\nThis field is immutable.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "resources": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceRequirements" + }, + "restartPolicy": { + "description": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", + "type": "string" + }, + "runtimeClassName": { + "description": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class", + "type": "string" + }, + "schedulerName": { + "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", + "type": "string" + }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\n\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "securityContext": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSecurityContext" + }, + "serviceAccount": { + "description": "DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.", + "type": "string" + }, + "serviceAccountName": { + "description": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/", + "type": "string" + }, + "setHostnameAsFQDN": { + "description": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\SYSTEM\\\\CurrentControlSet\\\\Services\\\\Tcpip\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "type": "boolean" + }, + "shareProcessNamespace": { + "description": "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.", + "type": "boolean" + }, + "subdomain": { + "description": "If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all.", + "type": "string" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", + "format": "int64", + "type": "integer" + }, + "tolerations": { + "description": "If specified, the pod's tolerations.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "topologySpreadConstraints": { + "description": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "topologyKey", + "whenUnsatisfiable" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "topologyKey", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "volumes": { + "description": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Volume" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge,retainKeys", + "nullable": true + }, + "workloadRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WorkloadReference" + } + }, + "required": [ + "containers" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PodTemplateSpec": { + "description": "PodTemplateSpec describes the data a pod should have when created from a template", + "properties": { + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSpec" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PreferredSchedulingTerm": { + "description": "An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).", + "properties": { + "preference": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "weight": { + "default": 0, + "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "preference" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Probe": { + "description": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.", + "properties": { + "exec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ExecAction" + }, + "failureThreshold": { + "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "grpc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction" + }, + "httpGet": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction" + }, + "initialDelaySeconds": { + "description": "Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + }, + "periodSeconds": { + "description": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "successThreshold": { + "description": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.", + "format": "int32", + "type": "integer" + }, + "tcpSocket": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TCPSocketAction" + }, + "terminationGracePeriodSeconds": { + "description": "Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.", + "format": "int64", + "type": "integer" + }, + "timeoutSeconds": { + "description": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ProjectedVolumeSource": { + "description": "Represents a projected volume source", + "properties": { + "defaultMode": { + "description": "defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "sources": { + "description": "sources is the list of volume projections. Each entry in this list handles one source.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeProjection" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceClaim": { + "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.", + "properties": { + "name": { + "default": "", + "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.", + "type": "string" + }, + "request": { + "description": "Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ResourceFieldSelector": { + "description": "ResourceFieldSelector represents container resources (cpu, memory) and their output format", + "properties": { + "containerName": { + "description": "Container name: required for volumes, optional for env vars", + "type": "string" + }, + "divisor": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "resource": { + "default": "", + "description": "Required: resource to select", + "type": "string" + } + }, + "required": [ + "resource" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ResourceRequirements": { + "description": "ResourceRequirements describes the compute resource requirements.", + "properties": { + "claims": { + "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\n\nThis field depends on the DynamicResourceAllocation feature gate.\n\nThis field is immutable. It can only be set for containers.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ResourceClaim" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "nullable": true + }, + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SELinuxOptions": { + "description": "SELinuxOptions are the labels to be applied to the container", + "properties": { + "level": { + "description": "Level is SELinux level label that applies to the container.", + "type": "string" + }, + "role": { + "description": "Role is a SELinux role label that applies to the container.", + "type": "string" + }, + "type": { + "description": "Type is a SELinux type label that applies to the container.", + "type": "string" + }, + "user": { + "description": "User is a SELinux user label that applies to the container.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOVolumeSource": { + "description": "ScaleIOVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "sslEnabled": { + "description": "sslEnabled Flag enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SeccompProfile": { + "description": "SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.", + "properties": { + "localhostProfile": { + "description": "localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \"Localhost\". Must NOT be set for any other type.", + "type": "string" + }, + "type": { + "default": "", + "description": "type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.", + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object", + "x-kubernetes-unions": [ + { + "discriminator": "type", + "fields-to-discriminateBy": { + "localhostProfile": "LocalhostProfile" + } + } + ] + }, + "io.k8s.api.core.v1.SecretEnvSource": { + "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.", + "properties": { + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretKeySelector": { + "description": "SecretKeySelector selects a key of a Secret.", + "properties": { + "key": { + "default": "", + "description": "The key of the secret to select from. Must be a valid secret key.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "Specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "required": [ + "key" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.SecretProjection": { + "description": "Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.", + "properties": { + "items": { + "description": "items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "default": "", + "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "optional": { + "description": "optional field specify whether the Secret or its key must be defined", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecretVolumeSource": { + "description": "Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.", + "properties": { + "defaultMode": { + "description": "defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.", + "format": "int32", + "type": "integer" + }, + "items": { + "description": "items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.KeyToPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "optional": { + "description": "optional field specify whether the Secret or its keys must be defined", + "type": "boolean" + }, + "secretName": { + "description": "secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.SecurityContext": { + "description": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", + "properties": { + "allowPrivilegeEscalation": { + "description": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "appArmorProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AppArmorProfile" + }, + "capabilities": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Capabilities" + }, + "privileged": { + "description": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "procMount": { + "description": "procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "type": "string" + }, + "readOnlyRootFilesystem": { + "description": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "type": "boolean" + }, + "runAsGroup": { + "description": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "runAsNonRoot": { + "description": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "boolean" + }, + "runAsUser": { + "description": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "format": "int64", + "type": "integer" + }, + "seLinuxOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SELinuxOptions" + }, + "seccompProfile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SeccompProfile" + }, + "windowsOptions": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ServiceAccountTokenProjection": { + "description": "ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).", + "properties": { + "audience": { + "description": "audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.", + "format": "int64", + "type": "integer" + }, + "path": { + "default": "", + "description": "path is the path relative to the mount point of the file to project the token into.", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SleepAction": { + "description": "SleepAction describes a \"sleep\" action.", + "properties": { + "seconds": { + "default": 0, + "description": "Seconds is the number of seconds to sleep.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "seconds" + ], + "type": "object" + }, + "io.k8s.api.core.v1.StorageOSVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalObjectReference" + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.Sysctl": { + "description": "Sysctl defines a kernel parameter to be set", + "properties": { + "name": { + "default": "", + "description": "Name of a property to set", + "type": "string" + }, + "value": { + "default": "", + "description": "Value of a property to set", + "type": "string" + } + }, + "required": [ + "name", + "value" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TCPSocketAction": { + "description": "TCPSocketAction describes an action based on opening a socket", + "properties": { + "host": { + "description": "Optional: Host name to connect to, defaults to the pod IP.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + }, + "required": [ + "port" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySpreadConstraint": { + "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", + "properties": { + "labelSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\n\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "maxSkew": { + "default": 0, + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.", + "format": "int32", + "type": "integer" + }, + "nodeAffinityPolicy": { + "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\n\nIf this value is nil, the behavior is equivalent to the Honor policy.", + "type": "string" + }, + "nodeTaintsPolicy": { + "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\n\nIf this value is nil, the behavior is equivalent to the Ignore policy.", + "type": "string" + }, + "topologyKey": { + "default": "", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", + "type": "string" + }, + "whenUnsatisfiable": { + "default": "", + "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.", + "type": "string" + } + }, + "required": [ + "maxSkew", + "topologyKey", + "whenUnsatisfiable" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.TypedObjectReference": { + "description": "TypedObjectReference contains enough information to let you locate the typed referenced object", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.Volume": { + "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", + "properties": { + "awsElasticBlockStore": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + }, + "azureDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + }, + "azureFile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource" + }, + "cephfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource" + }, + "cinder": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource" + }, + "csi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource" + }, + "emptyDir": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource" + }, + "ephemeral": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource" + }, + "fc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + }, + "flexVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource" + }, + "flocker": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + }, + "gcePersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + }, + "gitRepo": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource" + }, + "glusterfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource" + }, + "hostPath": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + }, + "image": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource" + }, + "iscsi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource" + }, + "name": { + "default": "", + "description": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "nfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + }, + "persistentVolumeClaim": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource" + }, + "photonPersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + }, + "portworxVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + }, + "projected": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource" + }, + "quobyte": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + }, + "rbd": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource" + }, + "scaleIO": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource" + }, + "storageos": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource" + }, + "vsphereVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeDevice": { + "description": "volumeDevice describes a mapping of a raw block device within a container.", + "properties": { + "devicePath": { + "default": "", + "description": "devicePath is the path inside of the container that the device will be mapped to.", + "type": "string" + }, + "name": { + "default": "", + "description": "name must match the name of a persistentVolumeClaim in the pod", + "type": "string" + } + }, + "required": [ + "name", + "devicePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeMount": { + "description": "VolumeMount describes a mounting of a Volume within a container.", + "properties": { + "mountPath": { + "default": "", + "description": "Path within the container at which the volume should be mounted. Must not contain ':'.", + "type": "string" + }, + "mountPropagation": { + "description": "mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).", + "type": "string" + }, + "name": { + "default": "", + "description": "This must match the Name of a Volume.", + "type": "string" + }, + "readOnly": { + "description": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.", + "type": "boolean" + }, + "recursiveReadOnly": { + "description": "RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\n\nIf ReadOnly is false, this field has no meaning and must be unspecified.\n\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\n\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\n\nIf this field is not specified, it is treated as an equivalent of Disabled.", + "type": "string" + }, + "subPath": { + "description": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).", + "type": "string" + }, + "subPathExpr": { + "description": "Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.", + "type": "string" + } + }, + "required": [ + "name", + "mountPath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.VolumeProjection": { + "description": "Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.", + "properties": { + "clusterTrustBundle": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection" + }, + "configMap": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection" + }, + "downwardAPI": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection" + }, + "podCertificate": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection" + }, + "secret": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretProjection" + }, + "serviceAccountToken": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VolumeResourceRequirements": { + "description": "VolumeResourceRequirements describes the storage resource requirements for a volume.", + "properties": { + "limits": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + }, + "requests": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WeightedPodAffinityTerm": { + "description": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)", + "properties": { + "podAffinityTerm": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm" + }, + "weight": { + "default": 0, + "description": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "weight", + "podAffinityTerm" + ], + "type": "object" + }, + "io.k8s.api.core.v1.WindowsSecurityContextOptions": { + "description": "WindowsSecurityContextOptions contain Windows-specific options and credentials.", + "properties": { + "gmsaCredentialSpec": { + "description": "GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.", + "type": "string" + }, + "gmsaCredentialSpecName": { + "description": "GMSACredentialSpecName is the name of the GMSA credential spec to use.", + "type": "string" + }, + "hostProcess": { + "description": "HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.", + "type": "boolean" + }, + "runAsUserName": { + "description": "The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.WorkloadReference": { + "description": "WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.", + "properties": { + "name": { + "default": "", + "description": "Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.", + "type": "string" + }, + "podGroup": { + "default": "", + "description": "PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.", + "type": "string" + }, + "podGroupReplicaKey": { + "description": "PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.", + "type": "string" + } + }, + "required": [ + "name", + "podGroup" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/batch/v1/": { + "get": { + "description": "get available resources", + "operationId": "getBatchV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ] + } + }, + "/apis/batch/v1/cronjobs": { + "get": { + "description": "list or watch objects of kind CronJob", + "operationId": "listBatchV1CronJobForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/jobs": { + "get": { + "description": "list or watch objects of kind Job", + "operationId": "listBatchV1JobForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs": { + "delete": { + "description": "delete collection of CronJob", + "operationId": "deleteBatchV1CollectionNamespacedCronJob", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CronJob", + "operationId": "listBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CronJob", + "operationId": "createBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}": { + "delete": { + "description": "delete a CronJob", + "operationId": "deleteBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "get": { + "description": "read the specified CronJob", + "operationId": "readBatchV1NamespacedCronJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CronJob", + "operationId": "patchBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CronJob", + "operationId": "replaceBatchV1NamespacedCronJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status": { + "get": { + "description": "read status of the specified CronJob", + "operationId": "readBatchV1NamespacedCronJobStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CronJob", + "operationId": "patchBatchV1NamespacedCronJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CronJob", + "operationId": "replaceBatchV1NamespacedCronJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.CronJob" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs": { + "delete": { + "description": "delete collection of Job", + "operationId": "deleteBatchV1CollectionNamespacedJob", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Job", + "operationId": "listBatchV1NamespacedJob", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.JobList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Job", + "operationId": "createBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs/{name}": { + "delete": { + "description": "delete a Job", + "operationId": "deleteBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "get": { + "description": "read the specified Job", + "operationId": "readBatchV1NamespacedJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Job", + "operationId": "patchBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Job", + "operationId": "replaceBatchV1NamespacedJob", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status": { + "get": { + "description": "read status of the specified Job", + "operationId": "readBatchV1NamespacedJobStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Job", + "operationId": "patchBatchV1NamespacedJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Job", + "operationId": "replaceBatchV1NamespacedJobStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.batch.v1.Job" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + } + }, + "/apis/batch/v1/watch/cronjobs": { + "get": { + "description": "watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1CronJobListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/jobs": { + "get": { + "description": "watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1JobListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs": { + "get": { + "description": "watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1NamespacedCronJobList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}": { + "get": { + "description": "watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchBatchV1NamespacedCronJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "CronJob", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CronJob", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/jobs": { + "get": { + "description": "watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchBatchV1NamespacedJobList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}": { + "get": { + "description": "watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchBatchV1NamespacedJob", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "batch_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "batch", + "kind": "Job", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Job", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_certificates.k8s.io_v1.json b/gen/openapi_v1/specs/apis_certificates.k8s.io_v1.json new file mode 100644 index 00000000..980da428 --- /dev/null +++ b/gen/openapi_v1/specs/apis_certificates.k8s.io_v1.json @@ -0,0 +1,3307 @@ +{ + "components": { + "schemas": { + "io.k8s.api.certificates.v1.CertificateSigningRequest": { + "description": "CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued.\n\nKubelets use this API to obtain:\n 1. client certificates to authenticate to kube-apiserver (with the \"kubernetes.io/kube-apiserver-client-kubelet\" signerName).\n 2. serving certificates for TLS endpoints kube-apiserver can connect to securely (with the \"kubernetes.io/kubelet-serving\" signerName).\n\nThis API can be used to request client certificates to authenticate to kube-apiserver (with the \"kubernetes.io/kube-apiserver-client\" signerName), or to obtain certificates from custom non-Kubernetes signers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {} + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec" + } + ], + "default": {}, + "description": "spec contains the certificate request, and is immutable after creation. Only the request, signerName, expirationSeconds, and usages fields can be set on creation. Other fields are derived by Kubernetes and cannot be modified by users." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus" + } + ], + "default": {}, + "description": "status contains information about whether the request is approved or denied, and the certificate issued by the signer, or the failure condition indicating signer failure." + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + ] + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestCondition": { + "description": "CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time." + }, + "lastUpdateTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastUpdateTime is the time of the last update to this condition" + }, + "message": { + "description": "message contains a human readable message with details about the request state", + "type": "string" + }, + "reason": { + "description": "reason indicates a brief reason for the request state", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown. Approved, Denied, and Failed conditions may not be \"False\" or \"Unknown\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type of the condition. Known conditions are \"Approved\", \"Denied\", and \"Failed\".\n\nAn \"Approved\" condition is added via the /approval subresource, indicating the request was approved and should be issued by the signer.\n\nA \"Denied\" condition is added via the /approval subresource, indicating the request was denied and should not be issued by the signer.\n\nA \"Failed\" condition is added via the /status subresource, indicating the signer failed to issue the certificate.\n\nApproved and Denied conditions are mutually exclusive. Approved, Denied, and Failed conditions cannot be removed once added.\n\nOnly one condition of a given type is allowed.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestList": { + "description": "CertificateSigningRequestList is a collection of CertificateSigningRequest objects", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a collection of CertificateSigningRequest objects", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {} + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequestList", + "version": "v1" + } + ] + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestSpec": { + "description": "CertificateSigningRequestSpec contains the certificate request.", + "properties": { + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration.\n\nThe v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager.\n\nCertificate signers may not honor this field for various reasons:\n\n 1. Old signer that is unaware of the field (such as the in-tree\n implementations prior to v1.22)\n 2. Signer whose configured maximum is shorter than the requested duration\n 3. Signer whose configured minimum is longer than the requested duration\n\nThe minimum valid value for expirationSeconds is 600, i.e. 10 minutes.", + "format": "int32", + "type": "integer" + }, + "extra": { + "additionalProperties": { + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "description": "extra contains extra attributes of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "object" + }, + "groups": { + "description": "groups contains group membership of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "request": { + "description": "request contains an x509 certificate signing request encoded in a \"CERTIFICATE REQUEST\" PEM block. When serialized as JSON or YAML, the data is additionally base64-encoded.", + "format": "byte", + "type": "string" + }, + "signerName": { + "default": "", + "description": "signerName indicates the requested signer, and is a qualified name.\n\nList/watch requests for CertificateSigningRequests can filter on this field using a \"spec.signerName=NAME\" fieldSelector.\n\nWell-known Kubernetes signers are:\n 1. \"kubernetes.io/kube-apiserver-client\": issues client certificates that can be used to authenticate to kube-apiserver.\n Requests for this signer are never auto-approved by kube-controller-manager, can be issued by the \"csrsigning\" controller in kube-controller-manager.\n 2. \"kubernetes.io/kube-apiserver-client-kubelet\": issues client certificates that kubelets use to authenticate to kube-apiserver.\n Requests for this signer can be auto-approved by the \"csrapproving\" controller in kube-controller-manager, and can be issued by the \"csrsigning\" controller in kube-controller-manager.\n 3. \"kubernetes.io/kubelet-serving\" issues serving certificates that kubelets use to serve TLS endpoints, which kube-apiserver can connect to securely.\n Requests for this signer are never auto-approved by kube-controller-manager, and can be issued by the \"csrsigning\" controller in kube-controller-manager.\n\nMore details are available at https://k8s.io/docs/reference/access-authn-authz/certificate-signing-requests/#kubernetes-signers\n\nCustom signerNames can also be specified. The signer defines:\n 1. Trust distribution: how trust (CA bundles) are distributed.\n 2. Permitted subjects: and behavior when a disallowed subject is requested.\n 3. Required, permitted, or forbidden x509 extensions in the request (including whether subjectAltNames are allowed, which types, restrictions on allowed values) and behavior when a disallowed extension is requested.\n 4. Required, permitted, or forbidden key usages / extended key usages.\n 5. Expiration/certificate lifetime: whether it is fixed by the signer, configurable by the admin.\n 6. Whether or not requests for CA certificates are allowed.", + "type": "string" + }, + "uid": { + "description": "uid contains the uid of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "string" + }, + "usages": { + "description": "usages specifies a set of key usages requested in the issued certificate.\n\nRequests for TLS client certificates typically request: \"digital signature\", \"key encipherment\", \"client auth\".\n\nRequests for TLS serving certificates typically request: \"key encipherment\", \"digital signature\", \"server auth\".\n\nValid values are:\n \"signing\", \"digital signature\", \"content commitment\",\n \"key encipherment\", \"key agreement\", \"data encipherment\",\n \"cert sign\", \"crl sign\", \"encipher only\", \"decipher only\", \"any\",\n \"server auth\", \"client auth\",\n \"code signing\", \"email protection\", \"s/mime\",\n \"ipsec end system\", \"ipsec tunnel\", \"ipsec user\",\n \"timestamping\", \"ocsp signing\", \"microsoft sgc\", \"netscape sgc\"", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "username": { + "description": "username contains the name of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "string" + } + }, + "required": [ + "request", + "signerName" + ], + "type": "object" + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestStatus": { + "description": "CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate.", + "properties": { + "certificate": { + "description": "certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable.\n\nIf the certificate signing request is denied, a condition of type \"Denied\" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type \"Failed\" is added and this field remains empty.\n\nValidation requirements:\n 1. certificate must contain one or more PEM blocks.\n 2. All PEM blocks must have the \"CERTIFICATE\" label, contain no headers, and the encoded data\n must be a BER-encoded ASN.1 Certificate structure as described in section 4 of RFC5280.\n 3. Non-PEM content may appear before or after the \"CERTIFICATE\" PEM blocks and is unvalidated,\n to allow for explanatory text as described in section 5.2 of RFC7468.\n\nIf more than one PEM block is present, and the definition of the requested spec.signerName does not indicate otherwise, the first block is the issued certificate, and subsequent blocks should be treated as intermediate certificates and presented in TLS handshakes.\n\nThe certificate is encoded in PEM format.\n\nWhen serialized as JSON or YAML, the data is additionally base64-encoded, so it consists of:\n\n base64(\n -----BEGIN CERTIFICATE-----\n ...\n -----END CERTIFICATE-----\n )", + "format": "byte", + "type": "string" + }, + "conditions": { + "description": "conditions applied to the request. Known conditions are \"Approved\", \"Denied\", and \"Failed\".", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/certificates.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCertificatesV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ] + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests": { + "delete": { + "description": "delete collection of CertificateSigningRequest", + "operationId": "deleteCertificatesV1CollectionCertificateSigningRequest", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CertificateSigningRequest", + "operationId": "listCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CertificateSigningRequest", + "operationId": "createCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}": { + "delete": { + "description": "delete a CertificateSigningRequest", + "operationId": "deleteCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "get": { + "description": "read the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequest", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval": { + "get": { + "description": "read approval of the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequestApproval", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update approval of the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequestApproval", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace approval of the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequestApproval", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status": { + "get": { + "description": "read status of the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequestStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequestStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequestStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests": { + "get": { + "description": "watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCertificatesV1CertificateSigningRequestList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}": { + "get": { + "description": "watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCertificatesV1CertificateSigningRequest", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_certificates.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_certificates.k8s.io_v1_patched.json new file mode 100644 index 00000000..a3e3799e --- /dev/null +++ b/gen/openapi_v1/specs/apis_certificates.k8s.io_v1_patched.json @@ -0,0 +1,3223 @@ +{ + "components": { + "schemas": { + "io.k8s.api.certificates.v1.CertificateSigningRequest": { + "description": "CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued.\n\nKubelets use this API to obtain:\n 1. client certificates to authenticate to kube-apiserver (with the \"kubernetes.io/kube-apiserver-client-kubelet\" signerName).\n 2. serving certificates for TLS endpoints kube-apiserver can connect to securely (with the \"kubernetes.io/kubelet-serving\" signerName).\n\nThis API can be used to request client certificates to authenticate to kube-apiserver (with the \"kubernetes.io/kube-apiserver-client\" signerName), or to obtain certificates from custom non-Kubernetes signers.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + ] + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestCondition": { + "description": "CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "lastUpdateTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "description": "message contains a human readable message with details about the request state", + "type": "string" + }, + "reason": { + "description": "reason indicates a brief reason for the request state", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown. Approved, Denied, and Failed conditions may not be \"False\" or \"Unknown\".", + "type": "string" + }, + "type": { + "default": "", + "description": "type of the condition. Known conditions are \"Approved\", \"Denied\", and \"Failed\".\n\nAn \"Approved\" condition is added via the /approval subresource, indicating the request was approved and should be issued by the signer.\n\nA \"Denied\" condition is added via the /approval subresource, indicating the request was denied and should not be issued by the signer.\n\nA \"Failed\" condition is added via the /status subresource, indicating the signer failed to issue the certificate.\n\nApproved and Denied conditions are mutually exclusive. Approved, Denied, and Failed conditions cannot be removed once added.\n\nOnly one condition of a given type is allowed.", + "type": "string" + } + }, + "required": [ + "type", + "status" + ], + "type": "object" + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestList": { + "description": "CertificateSigningRequestList is a collection of CertificateSigningRequest objects", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a collection of CertificateSigningRequest objects", + "items": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequestList", + "version": "v1" + } + ] + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestSpec": { + "description": "CertificateSigningRequestSpec contains the certificate request.", + "properties": { + "expirationSeconds": { + "description": "expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration.\n\nThe v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager.\n\nCertificate signers may not honor this field for various reasons:\n\n 1. Old signer that is unaware of the field (such as the in-tree\n implementations prior to v1.22)\n 2. Signer whose configured maximum is shorter than the requested duration\n 3. Signer whose configured minimum is longer than the requested duration\n\nThe minimum valid value for expirationSeconds is 600, i.e. 10 minutes.", + "format": "int32", + "type": "integer" + }, + "extra": { + "additionalProperties": { + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "description": "extra contains extra attributes of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "object" + }, + "groups": { + "description": "groups contains group membership of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "request": { + "description": "request contains an x509 certificate signing request encoded in a \"CERTIFICATE REQUEST\" PEM block. When serialized as JSON or YAML, the data is additionally base64-encoded.", + "format": "byte", + "type": "string" + }, + "signerName": { + "default": "", + "description": "signerName indicates the requested signer, and is a qualified name.\n\nList/watch requests for CertificateSigningRequests can filter on this field using a \"spec.signerName=NAME\" fieldSelector.\n\nWell-known Kubernetes signers are:\n 1. \"kubernetes.io/kube-apiserver-client\": issues client certificates that can be used to authenticate to kube-apiserver.\n Requests for this signer are never auto-approved by kube-controller-manager, can be issued by the \"csrsigning\" controller in kube-controller-manager.\n 2. \"kubernetes.io/kube-apiserver-client-kubelet\": issues client certificates that kubelets use to authenticate to kube-apiserver.\n Requests for this signer can be auto-approved by the \"csrapproving\" controller in kube-controller-manager, and can be issued by the \"csrsigning\" controller in kube-controller-manager.\n 3. \"kubernetes.io/kubelet-serving\" issues serving certificates that kubelets use to serve TLS endpoints, which kube-apiserver can connect to securely.\n Requests for this signer are never auto-approved by kube-controller-manager, and can be issued by the \"csrsigning\" controller in kube-controller-manager.\n\nMore details are available at https://k8s.io/docs/reference/access-authn-authz/certificate-signing-requests/#kubernetes-signers\n\nCustom signerNames can also be specified. The signer defines:\n 1. Trust distribution: how trust (CA bundles) are distributed.\n 2. Permitted subjects: and behavior when a disallowed subject is requested.\n 3. Required, permitted, or forbidden x509 extensions in the request (including whether subjectAltNames are allowed, which types, restrictions on allowed values) and behavior when a disallowed extension is requested.\n 4. Required, permitted, or forbidden key usages / extended key usages.\n 5. Expiration/certificate lifetime: whether it is fixed by the signer, configurable by the admin.\n 6. Whether or not requests for CA certificates are allowed.", + "type": "string" + }, + "uid": { + "description": "uid contains the uid of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "string" + }, + "usages": { + "description": "usages specifies a set of key usages requested in the issued certificate.\n\nRequests for TLS client certificates typically request: \"digital signature\", \"key encipherment\", \"client auth\".\n\nRequests for TLS serving certificates typically request: \"key encipherment\", \"digital signature\", \"server auth\".\n\nValid values are:\n \"signing\", \"digital signature\", \"content commitment\",\n \"key encipherment\", \"key agreement\", \"data encipherment\",\n \"cert sign\", \"crl sign\", \"encipher only\", \"decipher only\", \"any\",\n \"server auth\", \"client auth\",\n \"code signing\", \"email protection\", \"s/mime\",\n \"ipsec end system\", \"ipsec tunnel\", \"ipsec user\",\n \"timestamping\", \"ocsp signing\", \"microsoft sgc\", \"netscape sgc\"", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "username": { + "description": "username contains the name of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.", + "type": "string" + } + }, + "required": [ + "request", + "signerName" + ], + "type": "object" + }, + "io.k8s.api.certificates.v1.CertificateSigningRequestStatus": { + "description": "CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate.", + "properties": { + "certificate": { + "description": "certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable.\n\nIf the certificate signing request is denied, a condition of type \"Denied\" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type \"Failed\" is added and this field remains empty.\n\nValidation requirements:\n 1. certificate must contain one or more PEM blocks.\n 2. All PEM blocks must have the \"CERTIFICATE\" label, contain no headers, and the encoded data\n must be a BER-encoded ASN.1 Certificate structure as described in section 4 of RFC5280.\n 3. Non-PEM content may appear before or after the \"CERTIFICATE\" PEM blocks and is unvalidated,\n to allow for explanatory text as described in section 5.2 of RFC7468.\n\nIf more than one PEM block is present, and the definition of the requested spec.signerName does not indicate otherwise, the first block is the issued certificate, and subsequent blocks should be treated as intermediate certificates and presented in TLS handshakes.\n\nThe certificate is encoded in PEM format.\n\nWhen serialized as JSON or YAML, the data is additionally base64-encoded, so it consists of:\n\n base64(\n -----BEGIN CERTIFICATE-----\n ...\n -----END CERTIFICATE-----\n )", + "format": "byte", + "type": "string" + }, + "conditions": { + "description": "conditions applied to the request. Known conditions are \"Approved\", \"Denied\", and \"Failed\".", + "items": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/certificates.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCertificatesV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ] + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests": { + "delete": { + "description": "delete collection of CertificateSigningRequest", + "operationId": "deleteCertificatesV1CollectionCertificateSigningRequest", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CertificateSigningRequest", + "operationId": "listCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CertificateSigningRequest", + "operationId": "createCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}": { + "delete": { + "description": "delete a CertificateSigningRequest", + "operationId": "deleteCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "get": { + "description": "read the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequest", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequest", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval": { + "get": { + "description": "read approval of the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequestApproval", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update approval of the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequestApproval", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace approval of the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequestApproval", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status": { + "get": { + "description": "read status of the specified CertificateSigningRequest", + "operationId": "readCertificatesV1CertificateSigningRequestStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified CertificateSigningRequest", + "operationId": "patchCertificatesV1CertificateSigningRequestStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified CertificateSigningRequest", + "operationId": "replaceCertificatesV1CertificateSigningRequestStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + } + }, + "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests": { + "get": { + "description": "watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCertificatesV1CertificateSigningRequestList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}": { + "get": { + "description": "watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCertificatesV1CertificateSigningRequest", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "certificates_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "certificates.k8s.io", + "kind": "CertificateSigningRequest", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CertificateSigningRequest", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_coordination.k8s.io_v1.json b/gen/openapi_v1/specs/apis_coordination.k8s.io_v1.json new file mode 100644 index 00000000..1bcf968e --- /dev/null +++ b/gen/openapi_v1/specs/apis_coordination.k8s.io_v1.json @@ -0,0 +1,2957 @@ +{ + "components": { + "schemas": { + "io.k8s.api.coordination.v1.Lease": { + "description": "Lease defines a lease concept.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseSpec" + } + ], + "default": {}, + "description": "spec contains the specification of the Lease. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + ] + }, + "io.k8s.api.coordination.v1.LeaseList": { + "description": "LeaseList is a list of Lease objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "coordination.k8s.io", + "kind": "LeaseList", + "version": "v1" + } + ] + }, + "io.k8s.api.coordination.v1.LeaseSpec": { + "description": "LeaseSpec is a specification of a Lease.", + "properties": { + "acquireTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "acquireTime is a time when the current lease was acquired." + }, + "holderIdentity": { + "description": "holderIdentity contains the identity of the holder of a current lease. If Coordinated Leader Election is used, the holder identity must be equal to the elected LeaseCandidate.metadata.name field.", + "type": "string" + }, + "leaseDurationSeconds": { + "description": "leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measured against the time of last observed renewTime.", + "format": "int32", + "type": "integer" + }, + "leaseTransitions": { + "description": "leaseTransitions is the number of transitions of a lease between holders.", + "format": "int32", + "type": "integer" + }, + "preferredHolder": { + "description": "PreferredHolder signals to a lease holder that the lease has a more optimal holder and should be given up. This field can only be set if Strategy is also set.", + "type": "string" + }, + "renewTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "renewTime is a time when the current holder of a lease has last updated the lease." + }, + "strategy": { + "description": "Strategy indicates the strategy for picking the leader for coordinated leader election. If the field is not specified, there is no active coordination for this lease. (Alpha) Using this field requires the CoordinatedLeaderElection feature gate to be enabled.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/coordination.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCoordinationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ] + } + }, + "/apis/coordination.k8s.io/v1/leases": { + "get": { + "description": "list or watch objects of kind Lease", + "operationId": "listCoordinationV1LeaseForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases": { + "delete": { + "description": "delete collection of Lease", + "operationId": "deleteCoordinationV1CollectionNamespacedLease", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Lease", + "operationId": "listCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Lease", + "operationId": "createCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + } + }, + "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}": { + "delete": { + "description": "delete a Lease", + "operationId": "deleteCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "get": { + "description": "read the specified Lease", + "operationId": "readCoordinationV1NamespacedLease", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Lease", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Lease", + "operationId": "patchCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Lease", + "operationId": "replaceCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + } + }, + "/apis/coordination.k8s.io/v1/watch/leases": { + "get": { + "description": "watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoordinationV1LeaseListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases": { + "get": { + "description": "watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoordinationV1NamespacedLeaseList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}": { + "get": { + "description": "watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoordinationV1NamespacedLease", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Lease", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_coordination.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_coordination.k8s.io_v1_patched.json new file mode 100644 index 00000000..439a35e2 --- /dev/null +++ b/gen/openapi_v1/specs/apis_coordination.k8s.io_v1_patched.json @@ -0,0 +1,2880 @@ +{ + "components": { + "schemas": { + "io.k8s.api.coordination.v1.Lease": { + "description": "Lease defines a lease concept.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseSpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + ] + }, + "io.k8s.api.coordination.v1.LeaseList": { + "description": "LeaseList is a list of Lease objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "coordination.k8s.io", + "kind": "LeaseList", + "version": "v1" + } + ] + }, + "io.k8s.api.coordination.v1.LeaseSpec": { + "description": "LeaseSpec is a specification of a Lease.", + "properties": { + "acquireTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + }, + "holderIdentity": { + "description": "holderIdentity contains the identity of the holder of a current lease. If Coordinated Leader Election is used, the holder identity must be equal to the elected LeaseCandidate.metadata.name field.", + "type": "string" + }, + "leaseDurationSeconds": { + "description": "leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measured against the time of last observed renewTime.", + "format": "int32", + "type": "integer" + }, + "leaseTransitions": { + "description": "leaseTransitions is the number of transitions of a lease between holders.", + "format": "int32", + "type": "integer" + }, + "preferredHolder": { + "description": "PreferredHolder signals to a lease holder that the lease has a more optimal holder and should be given up. This field can only be set if Strategy is also set.", + "type": "string" + }, + "renewTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + }, + "strategy": { + "description": "Strategy indicates the strategy for picking the leader for coordinated leader election. If the field is not specified, there is no active coordination for this lease. (Alpha) Using this field requires the CoordinatedLeaderElection feature gate to be enabled.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/coordination.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getCoordinationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ] + } + }, + "/apis/coordination.k8s.io/v1/leases": { + "get": { + "description": "list or watch objects of kind Lease", + "operationId": "listCoordinationV1LeaseForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases": { + "delete": { + "description": "delete collection of Lease", + "operationId": "deleteCoordinationV1CollectionNamespacedLease", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Lease", + "operationId": "listCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.LeaseList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Lease", + "operationId": "createCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + } + }, + "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}": { + "delete": { + "description": "delete a Lease", + "operationId": "deleteCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "get": { + "description": "read the specified Lease", + "operationId": "readCoordinationV1NamespacedLease", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Lease", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Lease", + "operationId": "patchCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Lease", + "operationId": "replaceCoordinationV1NamespacedLease", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.coordination.v1.Lease" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + } + }, + "/apis/coordination.k8s.io/v1/watch/leases": { + "get": { + "description": "watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoordinationV1LeaseListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases": { + "get": { + "description": "watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchCoordinationV1NamespacedLeaseList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}": { + "get": { + "description": "watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchCoordinationV1NamespacedLease", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "coordination_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "coordination.k8s.io", + "kind": "Lease", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Lease", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_discovery.k8s.io_v1.json b/gen/openapi_v1/specs/apis_discovery.k8s.io_v1.json new file mode 100644 index 00000000..64d668dd --- /dev/null +++ b/gen/openapi_v1/specs/apis_discovery.k8s.io_v1.json @@ -0,0 +1,3134 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.discovery.v1.Endpoint": { + "description": "Endpoint represents a single logical \"backend\" implementing a service.", + "properties": { + "addresses": { + "description": "addresses of this endpoint. For EndpointSlices of addressType \"IPv4\" or \"IPv6\", the values are IP addresses in canonical form. The syntax and semantics of other addressType values are not defined. This must contain at least one address but no more than 100. EndpointSlices generated by the EndpointSlice controller will always have exactly 1 address. No semantics are defined for additional addresses beyond the first, and kube-proxy does not look at them.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set" + }, + "conditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointConditions" + } + ], + "default": {}, + "description": "conditions contains information about the current status of the endpoint." + }, + "deprecatedTopology": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "deprecatedTopology contains topology information part of the v1beta1 API. This field is deprecated, and will be removed when the v1beta1 API is removed (no sooner than kubernetes v1.24). While this field can hold values, it is not writable through the v1 API, and any attempts to write to it will be silently ignored. Topology information can be found in the zone and nodeName fields instead.", + "type": "object" + }, + "hints": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointHints" + } + ], + "description": "hints contains information associated with how an endpoint should be consumed." + }, + "hostname": { + "description": "hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must be lowercase and pass DNS Label (RFC 1123) validation.", + "type": "string" + }, + "nodeName": { + "description": "nodeName represents the name of the Node hosting this endpoint. This can be used to determine endpoints local to a Node.", + "type": "string" + }, + "targetRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "targetRef is a reference to a Kubernetes object that represents this endpoint." + }, + "zone": { + "description": "zone is the name of the Zone this endpoint exists in.", + "type": "string" + } + }, + "required": [ + "addresses" + ], + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointConditions": { + "description": "EndpointConditions represents the current condition of an endpoint.", + "properties": { + "ready": { + "description": "ready indicates that this endpoint is ready to receive traffic, according to whatever system is managing the endpoint. A nil value should be interpreted as \"true\". In general, an endpoint should be marked ready if it is serving and not terminating, though this can be overridden in some cases, such as when the associated Service has set the publishNotReadyAddresses flag.", + "type": "boolean" + }, + "serving": { + "description": "serving indicates that this endpoint is able to receive traffic, according to whatever system is managing the endpoint. For endpoints backed by pods, the EndpointSlice controller will mark the endpoint as serving if the pod's Ready condition is True. A nil value should be interpreted as \"true\".", + "type": "boolean" + }, + "terminating": { + "description": "terminating indicates that this endpoint is terminating. A nil value should be interpreted as \"false\".", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointHints": { + "description": "EndpointHints provides hints describing how an endpoint should be consumed.", + "properties": { + "forNodes": { + "description": "forNodes indicates the node(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.ForNode" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "forZones": { + "description": "forZones indicates the zone(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.ForZone" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointPort": { + "description": "EndpointPort represents a Port used by an EndpointSlice", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "name represents the name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is derived from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string.", + "type": "string" + }, + "port": { + "description": "port represents the port number of the endpoint. If the EndpointSlice is derived from a Kubernetes service, this must be set to the service's target port. EndpointSlices used for other purposes may have a nil port.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "description": "protocol represents the IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.discovery.v1.EndpointSlice": { + "description": "EndpointSlice represents a set of service endpoints. Most EndpointSlices are created by the EndpointSlice controller to represent the Pods selected by Service objects. For a given service there may be multiple EndpointSlice objects which must be joined to produce the full set of endpoints; you can find all of the slices for a given service by listing EndpointSlices in the service's namespace whose `kubernetes.io/service-name` label contains the service's name.", + "properties": { + "addressType": { + "default": "", + "description": "addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. (Deprecated) The EndpointSlice controller only generates, and kube-proxy only processes, slices of addressType \"IPv4\" and \"IPv6\". No semantics are defined for the \"FQDN\" type.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "endpoints": { + "description": "endpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.Endpoint" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + }, + "ports": { + "description": "ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. Each slice may include a maximum of 100 ports. Services always have at least 1 port, so EndpointSlices generated by the EndpointSlice controller will likewise always have at least 1 port. EndpointSlices used for other purposes may have an empty ports list.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "addressType", + "endpoints" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + ] + }, + "io.k8s.api.discovery.v1.EndpointSliceList": { + "description": "EndpointSliceList represents a list of endpoint slices", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of endpoint slices", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "discovery.k8s.io", + "kind": "EndpointSliceList", + "version": "v1" + } + ] + }, + "io.k8s.api.discovery.v1.ForNode": { + "description": "ForNode provides information about which nodes should consume this endpoint.", + "properties": { + "name": { + "default": "", + "description": "name represents the name of the node.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.discovery.v1.ForZone": { + "description": "ForZone provides information about which zones should consume this endpoint.", + "properties": { + "name": { + "default": "", + "description": "name represents the name of the zone.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/discovery.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getDiscoveryV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ] + } + }, + "/apis/discovery.k8s.io/v1/endpointslices": { + "get": { + "description": "list or watch objects of kind EndpointSlice", + "operationId": "listDiscoveryV1EndpointSliceForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices": { + "delete": { + "description": "delete collection of EndpointSlice", + "operationId": "deleteDiscoveryV1CollectionNamespacedEndpointSlice", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind EndpointSlice", + "operationId": "listDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an EndpointSlice", + "operationId": "createDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + } + }, + "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}": { + "delete": { + "description": "delete an EndpointSlice", + "operationId": "deleteDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "get": { + "description": "read the specified EndpointSlice", + "operationId": "readDiscoveryV1NamespacedEndpointSlice", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the EndpointSlice", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified EndpointSlice", + "operationId": "patchDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "put": { + "description": "replace the specified EndpointSlice", + "operationId": "replaceDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + } + }, + "/apis/discovery.k8s.io/v1/watch/endpointslices": { + "get": { + "description": "watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchDiscoveryV1EndpointSliceListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices": { + "get": { + "description": "watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchDiscoveryV1NamespacedEndpointSliceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}": { + "get": { + "description": "watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchDiscoveryV1NamespacedEndpointSlice", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the EndpointSlice", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_discovery.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_discovery.k8s.io_v1_patched.json new file mode 100644 index 00000000..cdc6a408 --- /dev/null +++ b/gen/openapi_v1/specs/apis_discovery.k8s.io_v1_patched.json @@ -0,0 +1,3041 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.discovery.v1.Endpoint": { + "description": "Endpoint represents a single logical \"backend\" implementing a service.", + "properties": { + "addresses": { + "description": "addresses of this endpoint. For EndpointSlices of addressType \"IPv4\" or \"IPv6\", the values are IP addresses in canonical form. The syntax and semantics of other addressType values are not defined. This must contain at least one address but no more than 100. EndpointSlices generated by the EndpointSlice controller will always have exactly 1 address. No semantics are defined for additional addresses beyond the first, and kube-proxy does not look at them.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + }, + "conditions": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointConditions" + }, + "deprecatedTopology": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "deprecatedTopology contains topology information part of the v1beta1 API. This field is deprecated, and will be removed when the v1beta1 API is removed (no sooner than kubernetes v1.24). While this field can hold values, it is not writable through the v1 API, and any attempts to write to it will be silently ignored. Topology information can be found in the zone and nodeName fields instead.", + "type": "object" + }, + "hints": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointHints" + }, + "hostname": { + "description": "hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must be lowercase and pass DNS Label (RFC 1123) validation.", + "type": "string" + }, + "nodeName": { + "description": "nodeName represents the name of the Node hosting this endpoint. This can be used to determine endpoints local to a Node.", + "type": "string" + }, + "targetRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "zone": { + "description": "zone is the name of the Zone this endpoint exists in.", + "type": "string" + } + }, + "required": [ + "addresses" + ], + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointConditions": { + "description": "EndpointConditions represents the current condition of an endpoint.", + "properties": { + "ready": { + "description": "ready indicates that this endpoint is ready to receive traffic, according to whatever system is managing the endpoint. A nil value should be interpreted as \"true\". In general, an endpoint should be marked ready if it is serving and not terminating, though this can be overridden in some cases, such as when the associated Service has set the publishNotReadyAddresses flag.", + "type": "boolean" + }, + "serving": { + "description": "serving indicates that this endpoint is able to receive traffic, according to whatever system is managing the endpoint. For endpoints backed by pods, the EndpointSlice controller will mark the endpoint as serving if the pod's Ready condition is True. A nil value should be interpreted as \"true\".", + "type": "boolean" + }, + "terminating": { + "description": "terminating indicates that this endpoint is terminating. A nil value should be interpreted as \"false\".", + "type": "boolean" + } + }, + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointHints": { + "description": "EndpointHints provides hints describing how an endpoint should be consumed.", + "properties": { + "forNodes": { + "description": "forNodes indicates the node(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.ForNode" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "forZones": { + "description": "forZones indicates the zone(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.ForZone" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.discovery.v1.EndpointPort": { + "description": "EndpointPort represents a Port used by an EndpointSlice", + "properties": { + "appProtocol": { + "description": "The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\n\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\n\n* Kubernetes-defined prefixed names:\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\n\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.", + "type": "string" + }, + "name": { + "description": "name represents the name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is derived from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string.", + "type": "string" + }, + "port": { + "description": "port represents the port number of the endpoint. If the EndpointSlice is derived from a Kubernetes service, this must be set to the service's target port. EndpointSlices used for other purposes may have a nil port.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "description": "protocol represents the IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.discovery.v1.EndpointSlice": { + "description": "EndpointSlice represents a set of service endpoints. Most EndpointSlices are created by the EndpointSlice controller to represent the Pods selected by Service objects. For a given service there may be multiple EndpointSlice objects which must be joined to produce the full set of endpoints; you can find all of the slices for a given service by listing EndpointSlices in the service's namespace whose `kubernetes.io/service-name` label contains the service's name.", + "properties": { + "addressType": { + "default": "", + "description": "addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. (Deprecated) The EndpointSlice controller only generates, and kube-proxy only processes, slices of addressType \"IPv4\" and \"IPv6\". No semantics are defined for the \"FQDN\" type.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "endpoints": { + "description": "endpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.Endpoint" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "ports": { + "description": "ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. Each slice may include a maximum of 100 ports. Services always have at least 1 port, so EndpointSlices generated by the EndpointSlice controller will likewise always have at least 1 port. EndpointSlices used for other purposes may have an empty ports list.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointPort" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "addressType", + "endpoints" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + ] + }, + "io.k8s.api.discovery.v1.EndpointSliceList": { + "description": "EndpointSliceList represents a list of endpoint slices", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of endpoint slices", + "items": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "discovery.k8s.io", + "kind": "EndpointSliceList", + "version": "v1" + } + ] + }, + "io.k8s.api.discovery.v1.ForNode": { + "description": "ForNode provides information about which nodes should consume this endpoint.", + "properties": { + "name": { + "default": "", + "description": "name represents the name of the node.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.discovery.v1.ForZone": { + "description": "ForZone provides information about which zones should consume this endpoint.", + "properties": { + "name": { + "default": "", + "description": "name represents the name of the zone.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/discovery.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getDiscoveryV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ] + } + }, + "/apis/discovery.k8s.io/v1/endpointslices": { + "get": { + "description": "list or watch objects of kind EndpointSlice", + "operationId": "listDiscoveryV1EndpointSliceForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices": { + "delete": { + "description": "delete collection of EndpointSlice", + "operationId": "deleteDiscoveryV1CollectionNamespacedEndpointSlice", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind EndpointSlice", + "operationId": "listDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an EndpointSlice", + "operationId": "createDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + } + }, + "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}": { + "delete": { + "description": "delete an EndpointSlice", + "operationId": "deleteDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "get": { + "description": "read the specified EndpointSlice", + "operationId": "readDiscoveryV1NamespacedEndpointSlice", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the EndpointSlice", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified EndpointSlice", + "operationId": "patchDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "put": { + "description": "replace the specified EndpointSlice", + "operationId": "replaceDiscoveryV1NamespacedEndpointSlice", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + } + }, + "/apis/discovery.k8s.io/v1/watch/endpointslices": { + "get": { + "description": "watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchDiscoveryV1EndpointSliceListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices": { + "get": { + "description": "watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchDiscoveryV1NamespacedEndpointSliceList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}": { + "get": { + "description": "watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchDiscoveryV1NamespacedEndpointSlice", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "discovery_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "discovery.k8s.io", + "kind": "EndpointSlice", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the EndpointSlice", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_events.k8s.io_v1.json b/gen/openapi_v1/specs/apis_events.k8s.io_v1.json new file mode 100644 index 00000000..66270d22 --- /dev/null +++ b/gen/openapi_v1/specs/apis_events.k8s.io_v1.json @@ -0,0 +1,3067 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.EventSource": { + "description": "EventSource contains information for an event.", + "properties": { + "component": { + "description": "Component from which the event is generated.", + "type": "string" + }, + "host": { + "description": "Node name on which the event is generated.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.events.v1.Event": { + "description": "Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.", + "properties": { + "action": { + "description": "action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "deprecatedCount": { + "description": "deprecatedCount is the deprecated field assuring backward compatibility with core.v1 Event type.", + "format": "int32", + "type": "integer" + }, + "deprecatedFirstTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "deprecatedFirstTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type." + }, + "deprecatedLastTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "deprecatedLastTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type." + }, + "deprecatedSource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSource" + } + ], + "default": {}, + "description": "deprecatedSource is the deprecated field assuring backward compatibility with core.v1 Event type." + }, + "eventTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "eventTime is the time when this Event was first observed. It is required." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "note": { + "description": "note is a human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB.", + "type": "string" + }, + "reason": { + "description": "reason is why the action was taken. It is human-readable. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "regarding": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "default": {}, + "description": "regarding contains the object this Event is about. In most cases it's an Object reporting controller implements, e.g. ReplicaSetController implements ReplicaSets and this event is emitted because it acts on some changes in a ReplicaSet object." + }, + "related": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "related is the optional secondary object for more complex actions. E.g. when regarding object triggers a creation or deletion of related object." + }, + "reportingController": { + "description": "reportingController is the name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. This field cannot be empty for new Events.", + "type": "string" + }, + "reportingInstance": { + "description": "reportingInstance is the ID of the controller instance, e.g. `kubelet-xyzf`. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "series": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventSeries" + } + ], + "description": "series is data about the Event series this event represents or nil if it's a singleton Event." + }, + "type": { + "description": "type is the type of this event (Normal, Warning), new types could be added in the future. It is machine-readable. This field cannot be empty for new Events.", + "type": "string" + } + }, + "required": [ + "eventTime" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + ] + }, + "io.k8s.api.events.v1.EventList": { + "description": "EventList is a list of Event objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "events.k8s.io", + "kind": "EventList", + "version": "v1" + } + ] + }, + "io.k8s.api.events.v1.EventSeries": { + "description": "EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in \"k8s.io/client-go/tools/events/event_broadcaster.go\" shows how this struct is updated on heartbeats and can guide customized reporter implementations.", + "properties": { + "count": { + "default": 0, + "description": "count is the number of occurrences in this series up to the last heartbeat time.", + "format": "int32", + "type": "integer" + }, + "lastObservedTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + ], + "description": "lastObservedTime is the time when last Event from the series was seen before last heartbeat." + } + }, + "required": [ + "count", + "lastObservedTime" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/events.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getEventsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ] + } + }, + "/apis/events.k8s.io/v1/events": { + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listEventsV1EventForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/namespaces/{namespace}/events": { + "delete": { + "description": "delete collection of Event", + "operationId": "deleteEventsV1CollectionNamespacedEvent", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listEventsV1NamespacedEvent", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Event", + "operationId": "createEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + } + }, + "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}": { + "delete": { + "description": "delete an Event", + "operationId": "deleteEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "read the specified Event", + "operationId": "readEventsV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Event", + "operationId": "patchEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Event", + "operationId": "replaceEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + } + }, + "/apis/events.k8s.io/v1/watch/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchEventsV1EventListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchEventsV1NamespacedEventList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}": { + "get": { + "description": "watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchEventsV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_events.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_events.k8s.io_v1_patched.json new file mode 100644 index 00000000..14f67243 --- /dev/null +++ b/gen/openapi_v1/specs/apis_events.k8s.io_v1_patched.json @@ -0,0 +1,2964 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.EventSource": { + "description": "EventSource contains information for an event.", + "properties": { + "component": { + "description": "Component from which the event is generated.", + "type": "string" + }, + "host": { + "description": "Node name on which the event is generated.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.events.v1.Event": { + "description": "Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.", + "properties": { + "action": { + "description": "action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "deprecatedCount": { + "description": "deprecatedCount is the deprecated field assuring backward compatibility with core.v1 Event type.", + "format": "int32", + "type": "integer" + }, + "deprecatedFirstTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deprecatedLastTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deprecatedSource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.EventSource" + }, + "eventTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "note": { + "description": "note is a human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB.", + "type": "string" + }, + "reason": { + "description": "reason is why the action was taken. It is human-readable. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "regarding": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "related": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "reportingController": { + "description": "reportingController is the name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. This field cannot be empty for new Events.", + "type": "string" + }, + "reportingInstance": { + "description": "reportingInstance is the ID of the controller instance, e.g. `kubelet-xyzf`. This field cannot be empty for new Events and it can have at most 128 characters.", + "type": "string" + }, + "series": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventSeries" + }, + "type": { + "description": "type is the type of this event (Normal, Warning), new types could be added in the future. It is machine-readable. This field cannot be empty for new Events.", + "type": "string" + } + }, + "required": [ + "eventTime" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + ] + }, + "io.k8s.api.events.v1.EventList": { + "description": "EventList is a list of Event objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "events.k8s.io", + "kind": "EventList", + "version": "v1" + } + ] + }, + "io.k8s.api.events.v1.EventSeries": { + "description": "EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in \"k8s.io/client-go/tools/events/event_broadcaster.go\" shows how this struct is updated on heartbeats and can guide customized reporter implementations.", + "properties": { + "count": { + "default": 0, + "description": "count is the number of occurrences in this series up to the last heartbeat time.", + "format": "int32", + "type": "integer" + }, + "lastObservedTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime" + } + }, + "required": [ + "count", + "lastObservedTime" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": { + "description": "MicroTime is version of Time with microsecond level precision.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/events.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getEventsV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ] + } + }, + "/apis/events.k8s.io/v1/events": { + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listEventsV1EventForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/namespaces/{namespace}/events": { + "delete": { + "description": "delete collection of Event", + "operationId": "deleteEventsV1CollectionNamespacedEvent", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Event", + "operationId": "listEventsV1NamespacedEvent", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.EventList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Event", + "operationId": "createEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + } + }, + "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}": { + "delete": { + "description": "delete an Event", + "operationId": "deleteEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "get": { + "description": "read the specified Event", + "operationId": "readEventsV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Event", + "operationId": "patchEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Event", + "operationId": "replaceEventsV1NamespacedEvent", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.events.v1.Event" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + } + }, + "/apis/events.k8s.io/v1/watch/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchEventsV1EventListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events": { + "get": { + "description": "watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchEventsV1NamespacedEventList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}": { + "get": { + "description": "watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchEventsV1NamespacedEvent", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "events_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "events.k8s.io", + "kind": "Event", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Event", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1.json b/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1.json new file mode 100644 index 00000000..9a86dd96 --- /dev/null +++ b/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1.json @@ -0,0 +1,1228 @@ +{ + "openapi": "3.0.0", + "info": { + "title": "Kubernetes metrics-server", + "version": "v0.8.1" + }, + "paths": { + "/apis/metrics.k8s.io/v1beta1/": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "get available resources", + "operationId": "getMetricsV1beta1APIResources", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + } + } + } + } + }, + "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind PodMetrics", + "operationId": "listMetricsV1beta1NamespacedPodMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "read the specified PodMetrics", + "operationId": "readMetricsV1beta1NamespacedPodMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + } + } + } + }, + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + } + }, + "parameters": [ + { + "name": "name", + "in": "path", + "description": "name of the PodMetrics", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/nodes": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind NodeMetrics", + "operationId": "listMetricsV1beta1NodeMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "NodeMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/nodes/{name}": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "read the specified NodeMetrics", + "operationId": "readMetricsV1beta1NodeMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + } + } + } + }, + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "NodeMetrics" + } + }, + "parameters": [ + { + "name": "name", + "in": "path", + "description": "name of the NodeMetrics", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/pods": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind PodMetrics", + "operationId": "listMetricsV1beta1PodMetricsForAllNamespaces", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + }, + "components": { + "schemas": { + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "type": "object", + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string", + "default": "" + }, + "name": { + "description": "name is the plural name of the resource.", + "type": "string", + "default": "" + }, + "namespaced": { + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean", + "default": false + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string", + "default": "" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "type": "array", + "items": { + "type": "string", + "default": "" + } + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "type": "object", + "required": [ + "groupVersion", + "resources" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string", + "default": "" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ] + }, + "x-kubernetes-list-type": "atomic" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Duration": { + "description": "Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json.", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "type": "object", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "type": "integer", + "format": "int64" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "type": "object", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ] + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "type": "object", + "properties": { + "annotations": { + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + }, + "creationTimestamp": { + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "type": "integer", + "format": "int64" + }, + "deletionTimestamp": { + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "type": "integer", + "format": "int64" + }, + "labels": { + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ] + }, + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ] + }, + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "type": "object", + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string", + "default": "" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string", + "default": "" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string", + "default": "" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string", + "default": "" + } + }, + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "type": "string", + "format": "date-time" + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics": { + "description": "ContainerMetrics sets resource usage metrics of a container.", + "type": "object", + "required": [ + "name", + "usage" + ], + "properties": { + "name": { + "description": "Container name corresponding to the one from pod.spec.containers.", + "type": "string", + "default": "" + }, + "usage": { + "description": "The memory usage is the memory working set.", + "type": "object", + "additionalProperties": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ] + } + } + } + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics": { + "description": "NodeMetrics sets resource usage metrics of a node.", + "type": "object", + "required": [ + "timestamp", + "window", + "usage" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ] + }, + "timestamp": { + "description": "The following fields define time interval from which metrics were collected from the interval [Timestamp-Window, Timestamp].", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + }, + "usage": { + "description": "The memory usage is the memory working set.", + "type": "object", + "additionalProperties": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ] + } + }, + "window": { + "default": 0, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + } + ] + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "NodeMetrics", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList": { + "description": "NodeMetricsList is a list of NodeMetrics.", + "type": "object", + "required": [ + "items" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of node metrics.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + ] + } + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ] + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "NodeMetricsList", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics": { + "description": "PodMetrics sets resource usage metrics of a pod.", + "type": "object", + "required": [ + "timestamp", + "window", + "containers" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "containers": { + "description": "Metrics for all containers are collected within the same time window.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics" + } + ] + }, + "x-kubernetes-list-type": "atomic" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ] + }, + "timestamp": { + "description": "The following fields define time interval from which metrics were collected from the interval [Timestamp-Window, Timestamp].", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ] + }, + "window": { + "default": 0, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + } + ] + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "PodMetrics", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList": { + "description": "PodMetricsList is a list of PodMetrics.", + "type": "object", + "required": [ + "items" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pod metrics.", + "type": "array", + "items": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + ] + } + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ] + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "PodMetricsList", + "version": "v1beta1" + } + ] + } + } + } +} diff --git a/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1_patched.json b/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1_patched.json new file mode 100644 index 00000000..1022261e --- /dev/null +++ b/gen/openapi_v1/specs/apis_metrics.k8s.io_v1beta1_patched.json @@ -0,0 +1,1164 @@ +{ + "openapi": "3.0.0", + "info": { + "title": "Kubernetes metrics-server", + "version": "v0.8.1" + }, + "paths": { + "/apis/metrics.k8s.io/v1beta1/": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "get available resources", + "operationId": "getMetricsV1beta1APIResources", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + } + } + } + } + }, + "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind PodMetrics", + "operationId": "listMetricsV1beta1NamespacedPodMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "read the specified PodMetrics", + "operationId": "readMetricsV1beta1NamespacedPodMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + } + } + } + } + }, + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "name": "name", + "in": "path", + "description": "name of the PodMetrics", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "namespace", + "in": "path", + "description": "object name and auth scope, such as for teams and projects", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/nodes": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind NodeMetrics", + "operationId": "listMetricsV1beta1NodeMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "NodeMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/nodes/{name}": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "read the specified NodeMetrics", + "operationId": "readMetricsV1beta1NodeMetrics", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + } + } + } + } + }, + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "NodeMetrics" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "name": "name", + "in": "path", + "description": "name of the NodeMetrics", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "/apis/metrics.k8s.io/v1beta1/pods": { + "get": { + "tags": [ + "metrics_v1beta1" + ], + "description": "list objects of kind PodMetrics", + "operationId": "listMetricsV1beta1PodMetricsForAllNamespaces", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList" + } + } + } + } + }, + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "metrics.k8s.io", + "version": "v1beta1", + "kind": "PodMetrics" + } + }, + "parameters": [ + { + "name": "allowWatchBookmarks", + "in": "query", + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "continue", + "in": "query", + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "fieldSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "labelSelector", + "in": "query", + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "limit", + "in": "query", + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "pretty", + "in": "query", + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersion", + "in": "query", + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "resourceVersionMatch", + "in": "query", + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "name": "sendInitialEvents", + "in": "query", + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "name": "timeoutSeconds", + "in": "query", + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "name": "watch", + "in": "query", + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + }, + "components": { + "schemas": { + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "type": "object", + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string", + "default": "" + }, + "name": { + "description": "name is the plural name of the resource.", + "type": "string", + "default": "" + }, + "namespaced": { + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean", + "default": false + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string", + "default": "" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "type": "object", + "required": [ + "groupVersion", + "resources" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string", + "default": "" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Duration": { + "description": "Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json.", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "type": "object", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "type": "integer", + "format": "int64" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "type": "object", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "type": "object", + "properties": { + "annotations": { + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "type": "integer", + "format": "int64" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "type": "array", + "items": { + "type": "string", + "default": "" + }, + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "type": "integer", + "format": "int64" + }, + "labels": { + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + } + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "type": "object", + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string", + "default": "" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string", + "default": "" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string", + "default": "" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string", + "default": "" + } + }, + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "type": "string", + "format": "date-time", + "nullable": true + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics": { + "description": "ContainerMetrics sets resource usage metrics of a container.", + "type": "object", + "required": [ + "name", + "usage" + ], + "properties": { + "name": { + "description": "Container name corresponding to the one from pod.spec.containers.", + "type": "string", + "default": "" + }, + "usage": { + "description": "The memory usage is the memory working set.", + "type": "object", + "additionalProperties": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ] + } + } + } + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics": { + "description": "NodeMetrics sets resource usage metrics of a node.", + "type": "object", + "required": [ + "timestamp", + "window", + "usage" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "timestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "usage": { + "description": "The memory usage is the memory working set.", + "type": "object", + "additionalProperties": { + "default": {}, + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ] + } + }, + "window": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "NodeMetrics", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList": { + "description": "NodeMetricsList is a list of NodeMetrics.", + "type": "object", + "required": [ + "items" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of node metrics.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics" + }, + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "NodeMetricsList", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics": { + "description": "PodMetrics sets resource usage metrics of a pod.", + "type": "object", + "required": [ + "timestamp", + "window", + "containers" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "containers": { + "description": "Metrics for all containers are collected within the same time window.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics" + }, + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "timestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "window": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "PodMetrics", + "version": "v1beta1" + } + ] + }, + "io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList": { + "description": "PodMetricsList is a list of PodMetrics.", + "type": "object", + "required": [ + "items" + ], + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "List of pod metrics.", + "type": "array", + "items": { + "$ref": "#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics" + }, + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "x-kubernetes-group-version-kind": [ + { + "group": "metrics.k8s.io", + "kind": "PodMetricsList", + "version": "v1beta1" + } + ] + } + } + } +} diff --git a/gen/openapi_v1/specs/apis_networking.k8s.io_v1.json b/gen/openapi_v1/specs/apis_networking.k8s.io_v1.json new file mode 100644 index 00000000..cc4bdb4a --- /dev/null +++ b/gen/openapi_v1/specs/apis_networking.k8s.io_v1.json @@ -0,0 +1,9910 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.networking.v1.HTTPIngressPath": { + "description": "HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend.", + "properties": { + "backend": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressBackend" + } + ], + "default": {}, + "description": "backend defines the referenced service endpoint to which the traffic will be forwarded to." + }, + "path": { + "description": "path is matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a '/' and must be present when using PathType with value \"Exact\" or \"Prefix\".", + "type": "string" + }, + "pathType": { + "description": "pathType determines the interpretation of the path matching. PathType can be one of the following values: * Exact: Matches the URL path exactly. * Prefix: Matches based on a URL path prefix split by '/'. Matching is\n done on a path element by element basis. A path element refers is the\n list of labels in the path split by the '/' separator. A request is a\n match for path p if every p is an element-wise prefix of p of the\n request path. Note that if the last element of the path is a substring\n of the last element in request path, it is not a match (e.g. /foo/bar\n matches /foo/bar/baz, but does not match /foo/barbaz).\n* ImplementationSpecific: Interpretation of the Path matching is up to\n the IngressClass. Implementations can treat this as a separate PathType\n or treat it identically to Prefix or Exact path types.\nImplementations are required to support all path types.", + "type": "string" + } + }, + "required": [ + "pathType", + "backend" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.HTTPIngressRuleValue": { + "description": "HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'.", + "properties": { + "paths": { + "description": "paths is a collection of paths that map requests to backends.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "paths" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IPAddress": { + "description": "IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressSpec" + } + ], + "default": {}, + "description": "spec is the desired state of the IPAddress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IPAddressList": { + "description": "IPAddressList contains a list of IPAddress.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of IPAddresses.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IPAddressList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IPAddressSpec": { + "description": "IPAddressSpec describe the attributes in an IP Address.", + "properties": { + "parentRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ParentReference" + } + ], + "description": "ParentRef references the resource that an IPAddress is attached to. An IPAddress must reference a parent object." + } + }, + "required": [ + "parentRef" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IPBlock": { + "description": "IPBlock describes a particular CIDR (Ex. \"192.168.1.0/24\",\"2001:db8::/64\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.", + "properties": { + "cidr": { + "default": "", + "description": "cidr is a string representing the IPBlock Valid examples are \"192.168.1.0/24\" or \"2001:db8::/64\"", + "type": "string" + }, + "except": { + "description": "except is a slice of CIDRs that should not be included within an IPBlock Valid examples are \"192.168.1.0/24\" or \"2001:db8::/64\" Except values will be rejected if they are outside the cidr range", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "cidr" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.Ingress": { + "description": "Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressSpec" + } + ], + "default": {}, + "description": "spec is the desired state of the Ingress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressStatus" + } + ], + "default": {}, + "description": "status is the current state of the Ingress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressBackend": { + "description": "IngressBackend describes all endpoints for a given service and port.", + "properties": { + "resource": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + } + ], + "description": "resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, a service.Name and service.Port must not be specified. This is a mutually exclusive setting with \"Service\"." + }, + "service": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend" + } + ], + "description": "service references a service as a backend. This is a mutually exclusive setting with \"Resource\"." + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressClass": { + "description": "IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassSpec" + } + ], + "default": {}, + "description": "spec is the desired state of the IngressClass. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressClassList": { + "description": "IngressClassList is a collection of IngressClasses.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of IngressClasses.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressClassParametersReference": { + "description": "IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource.", + "properties": { + "apiGroup": { + "description": "apiGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the type of resource being referenced.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of resource being referenced.", + "type": "string" + }, + "namespace": { + "description": "namespace is the namespace of the resource being referenced. This field is required when scope is set to \"Namespace\" and must be unset when scope is set to \"Cluster\".", + "type": "string" + }, + "scope": { + "description": "scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\".", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressClassSpec": { + "description": "IngressClassSpec provides information about the class of an Ingress.", + "properties": { + "controller": { + "description": "controller refers to the name of the controller that should handle this class. This allows for different \"flavors\" that are controlled by the same controller. For example, you may have different parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. \"acme.io/ingress-controller\". This field is immutable.", + "type": "string" + }, + "parameters": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference" + } + ], + "description": "parameters is a link to a custom resource containing additional configuration for the controller. This is optional if the controller does not require extra parameters." + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressList": { + "description": "IngressList is a collection of Ingress.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of Ingress.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressLoadBalancerIngress": { + "description": "IngressLoadBalancerIngress represents the status of a load-balancer ingress point.", + "properties": { + "hostname": { + "description": "hostname is set for load-balancer ingress points that are DNS based.", + "type": "string" + }, + "ip": { + "description": "ip is set for load-balancer ingress points that are IP based.", + "type": "string" + }, + "ports": { + "description": "ports provides information about the ports exposed by this LoadBalancer.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressPortStatus" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressLoadBalancerStatus": { + "description": "IngressLoadBalancerStatus represents the status of a load-balancer.", + "properties": { + "ingress": { + "description": "ingress is a list containing ingress points for the load-balancer.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressPortStatus": { + "description": "IngressPortStatus represents the error condition of a service port", + "properties": { + "error": { + "description": "error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\n CamelCase names\n- cloud provider specific error values must have names that comply with the\n format foo.example.com/CamelCase.", + "type": "string" + }, + "port": { + "default": 0, + "description": "port is the port number of the ingress port.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "", + "description": "protocol is the protocol of the ingress port. The supported values are: \"TCP\", \"UDP\", \"SCTP\"", + "type": "string" + } + }, + "required": [ + "port", + "protocol" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressRule": { + "description": "IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue.", + "properties": { + "host": { + "description": "host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to\n the IP in the Spec of the parent Ingress.\n2. The `:` delimiter is not respected because ports are not allowed.\n\t Currently the port of an Ingress is implicitly :80 for http and\n\t :443 for https.\nBoth these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue.\n\nhost can be \"precise\" which is a domain name without the terminating dot of a network host (e.g. \"foo.bar.com\") or \"wildcard\", which is a domain name prefixed with a single wildcard label (e.g. \"*.foo.com\"). The wildcard character '*' must appear by itself as the first DNS label and matches only a single label. You cannot have a wildcard label by itself (e.g. Host == \"*\"). Requests will be matched against the Host field in the following way: 1. If host is precise, the request matches this rule if the http host header is equal to Host. 2. If host is a wildcard, then the request matches this rule if the http host header is to equal to the suffix (removing the first label) of the wildcard rule.", + "type": "string" + }, + "http": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressServiceBackend": { + "description": "IngressServiceBackend references a Kubernetes Service as a Backend.", + "properties": { + "name": { + "default": "", + "description": "name is the referenced service. The service must exist in the same namespace as the Ingress object.", + "type": "string" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort" + } + ], + "default": {}, + "description": "port of the referenced service. A port name or port number is required for a IngressServiceBackend." + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressSpec": { + "description": "IngressSpec describes the Ingress the user wishes to exist.", + "properties": { + "defaultBackend": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressBackend" + } + ], + "description": "defaultBackend is the backend that should handle requests that don't match any rule. If Rules are not specified, DefaultBackend must be specified. If DefaultBackend is not set, the handling of requests that do not match any of the rules will be up to the Ingress controller." + }, + "ingressClassName": { + "description": "ingressClassName is the name of an IngressClass cluster resource. Ingress controller implementations use this field to know whether they should be serving this Ingress resource, by a transitive connection (controller -> IngressClass -> Ingress resource). Although the `kubernetes.io/ingress.class` annotation (simple constant name) was never formally defined, it was widely supported by Ingress controllers to create a direct binding between Ingress controller and Ingress resources. Newly created Ingress resources should prefer using the field. However, even though the annotation is officially deprecated, for backwards compatibility reasons, ingress controllers should still honor that annotation if present.", + "type": "string" + }, + "rules": { + "description": "rules is a list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "tls": { + "description": "tls represents the TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressTLS" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressStatus": { + "description": "IngressStatus describe the current state of the Ingress.", + "properties": { + "loadBalancer": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus" + } + ], + "default": {}, + "description": "loadBalancer contains the current status of the load-balancer." + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressTLS": { + "description": "IngressTLS describes the transport layer security associated with an ingress.", + "properties": { + "hosts": { + "description": "hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "secretName": { + "description": "secretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the \"Host\" header is used for routing.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicy": { + "description": "NetworkPolicy describes what network traffic is allowed for a set of Pods", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec" + } + ], + "default": {}, + "description": "spec represents the specification of the desired behavior for this NetworkPolicy." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.NetworkPolicyEgressRule": { + "description": "NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8", + "properties": { + "ports": { + "description": "ports is a list of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "to": { + "description": "to is a list of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyIngressRule": { + "description": "NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from.", + "properties": { + "from": { + "description": "from is a list of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ports": { + "description": "ports is a list of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyList": { + "description": "NetworkPolicyList is a list of NetworkPolicy objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "NetworkPolicyList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.NetworkPolicyPeer": { + "description": "NetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed", + "properties": { + "ipBlock": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPBlock" + } + ], + "description": "ipBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be." + }, + "namespaceSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "namespaceSelector selects namespaces using cluster-scoped labels. This field follows standard label selector semantics; if present but empty, it selects all namespaces.\n\nIf podSelector is also set, then the NetworkPolicyPeer as a whole selects the pods matching podSelector in the namespaces selected by namespaceSelector. Otherwise it selects all pods in the namespaces selected by namespaceSelector." + }, + "podSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "podSelector is a label selector which selects pods. This field follows standard label selector semantics; if present but empty, it selects all pods.\n\nIf namespaceSelector is also set, then the NetworkPolicyPeer as a whole selects the pods matching podSelector in the Namespaces selected by NamespaceSelector. Otherwise it selects the pods matching podSelector in the policy's own namespace." + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyPort": { + "description": "NetworkPolicyPort describes a port to allow traffic on", + "properties": { + "endPort": { + "description": "endPort indicates that the range of ports from port to endPort if set, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port.", + "format": "int32", + "type": "integer" + }, + "port": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "port represents the port on the given protocol. This can either be a numerical or named port on a pod. If this field is not provided, this matches all port names and numbers. If present, only traffic on the specified protocol AND port will be matched." + }, + "protocol": { + "description": "protocol represents the protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicySpec": { + "description": "NetworkPolicySpec provides the specification of a NetworkPolicy", + "properties": { + "egress": { + "description": "egress is a list of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "ingress": { + "description": "ingress is a list of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default)", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "podSelector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "default": {}, + "description": "podSelector selects the pods to which this NetworkPolicy object applies. The array of rules is applied to any pods selected by this field. An empty selector matches all pods in the policy's namespace. Multiple network policies can select the same set of pods. In this case, the ingress rules for each are combined additively. This field is optional. If it is not specified, it defaults to an empty selector." + }, + "policyTypes": { + "description": "policyTypes is a list of rule types that the NetworkPolicy relates to. Valid options are [\"Ingress\"], [\"Egress\"], or [\"Ingress\", \"Egress\"]. If this field is not specified, it will default based on the existence of ingress or egress rules; policies that contain an egress section are assumed to affect egress, and all policies (whether or not they contain an ingress section) are assumed to affect ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.ParentReference": { + "description": "ParentReference describes a reference to a parent object.", + "properties": { + "group": { + "description": "Group is the group of the object being referenced.", + "type": "string" + }, + "name": { + "description": "Name is the name of the object being referenced.", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of the object being referenced.", + "type": "string" + }, + "resource": { + "description": "Resource is the resource of the object being referenced.", + "type": "string" + } + }, + "required": [ + "resource", + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.ServiceBackendPort": { + "description": "ServiceBackendPort is the service port being referenced.", + "properties": { + "name": { + "description": "name is the name of the port on the Service. This is a mutually exclusive setting with \"Number\".", + "type": "string" + }, + "number": { + "description": "number is the numerical port number (e.g. 80) on the Service. This is a mutually exclusive setting with \"Name\".", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.networking.v1.ServiceCIDR": { + "description": "ServiceCIDR defines a range of IP addresses using CIDR format (e.g. 192.168.0.0/24 or 2001:db2::/64). This range is used to allocate ClusterIPs to Service objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec" + } + ], + "default": {}, + "description": "spec is the desired state of the ServiceCIDR. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus" + } + ], + "default": {}, + "description": "status represents the current state of the ServiceCIDR. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.ServiceCIDRList": { + "description": "ServiceCIDRList contains a list of ServiceCIDR objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of ServiceCIDRs.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "ServiceCIDRList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.ServiceCIDRSpec": { + "description": "ServiceCIDRSpec define the CIDRs the user wants to use for allocating ClusterIPs for Services.", + "properties": { + "cidrs": { + "description": "CIDRs defines the IP blocks in CIDR notation (e.g. \"192.168.0.0/24\" or \"2001:db8::/64\") from which to assign service cluster IPs. Max of two CIDRs is allowed, one of each IP family. This field is immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.ServiceCIDRStatus": { + "description": "ServiceCIDRStatus describes the current state of the ServiceCIDR.", + "properties": { + "conditions": { + "description": "conditions holds an array of metav1.Condition that describe the state of the ServiceCIDR. Current service state", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable." + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/networking.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getNetworkingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ] + } + }, + "/apis/networking.k8s.io/v1/ingressclasses": { + "delete": { + "description": "delete collection of IngressClass", + "operationId": "deleteNetworkingV1CollectionIngressClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind IngressClass", + "operationId": "listNetworkingV1IngressClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an IngressClass", + "operationId": "createNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ingressclasses/{name}": { + "delete": { + "description": "delete an IngressClass", + "operationId": "deleteNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified IngressClass", + "operationId": "readNetworkingV1IngressClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the IngressClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified IngressClass", + "operationId": "patchNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified IngressClass", + "operationId": "replaceNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ingresses": { + "get": { + "description": "list or watch objects of kind Ingress", + "operationId": "listNetworkingV1IngressForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/ipaddresses": { + "delete": { + "description": "delete collection of IPAddress", + "operationId": "deleteNetworkingV1CollectionIPAddress", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind IPAddress", + "operationId": "listNetworkingV1IPAddress", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an IPAddress", + "operationId": "createNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ipaddresses/{name}": { + "delete": { + "description": "delete an IPAddress", + "operationId": "deleteNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "get": { + "description": "read the specified IPAddress", + "operationId": "readNetworkingV1IPAddress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the IPAddress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified IPAddress", + "operationId": "patchNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "put": { + "description": "replace the specified IPAddress", + "operationId": "replaceNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses": { + "delete": { + "description": "delete collection of Ingress", + "operationId": "deleteNetworkingV1CollectionNamespacedIngress", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Ingress", + "operationId": "listNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Ingress", + "operationId": "createNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}": { + "delete": { + "description": "delete an Ingress", + "operationId": "deleteNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "get": { + "description": "read the specified Ingress", + "operationId": "readNetworkingV1NamespacedIngress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Ingress", + "operationId": "patchNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Ingress", + "operationId": "replaceNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status": { + "get": { + "description": "read status of the specified Ingress", + "operationId": "readNetworkingV1NamespacedIngressStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Ingress", + "operationId": "patchNetworkingV1NamespacedIngressStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Ingress", + "operationId": "replaceNetworkingV1NamespacedIngressStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies": { + "delete": { + "description": "delete collection of NetworkPolicy", + "operationId": "deleteNetworkingV1CollectionNamespacedNetworkPolicy", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind NetworkPolicy", + "operationId": "listNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a NetworkPolicy", + "operationId": "createNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}": { + "delete": { + "description": "delete a NetworkPolicy", + "operationId": "deleteNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "get": { + "description": "read the specified NetworkPolicy", + "operationId": "readNetworkingV1NamespacedNetworkPolicy", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the NetworkPolicy", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified NetworkPolicy", + "operationId": "patchNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "put": { + "description": "replace the specified NetworkPolicy", + "operationId": "replaceNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/networkpolicies": { + "get": { + "description": "list or watch objects of kind NetworkPolicy", + "operationId": "listNetworkingV1NetworkPolicyForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/servicecidrs": { + "delete": { + "description": "delete collection of ServiceCIDR", + "operationId": "deleteNetworkingV1CollectionServiceCIDR", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ServiceCIDR", + "operationId": "listNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ServiceCIDR", + "operationId": "createNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/servicecidrs/{name}": { + "delete": { + "description": "delete a ServiceCIDR", + "operationId": "deleteNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "get": { + "description": "read the specified ServiceCIDR", + "operationId": "readNetworkingV1ServiceCIDR", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ServiceCIDR", + "operationId": "patchNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ServiceCIDR", + "operationId": "replaceNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/servicecidrs/{name}/status": { + "get": { + "description": "read status of the specified ServiceCIDR", + "operationId": "readNetworkingV1ServiceCIDRStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ServiceCIDR", + "operationId": "patchNetworkingV1ServiceCIDRStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ServiceCIDR", + "operationId": "replaceNetworkingV1ServiceCIDRStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/watch/ingressclasses": { + "get": { + "description": "watch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IngressClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ingressclasses/{name}": { + "get": { + "description": "watch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1IngressClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the IngressClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ingresses": { + "get": { + "description": "watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IngressListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ipaddresses": { + "get": { + "description": "watch individual changes to a list of IPAddress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IPAddressList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ipaddresses/{name}": { + "get": { + "description": "watch changes to an object of kind IPAddress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1IPAddress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the IPAddress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses": { + "get": { + "description": "watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NamespacedIngressList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}": { + "get": { + "description": "watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1NamespacedIngress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies": { + "get": { + "description": "watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NamespacedNetworkPolicyList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}": { + "get": { + "description": "watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1NamespacedNetworkPolicy", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the NetworkPolicy", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/networkpolicies": { + "get": { + "description": "watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NetworkPolicyListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/servicecidrs": { + "get": { + "description": "watch individual changes to a list of ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1ServiceCIDRList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/servicecidrs/{name}": { + "get": { + "description": "watch changes to an object of kind ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1ServiceCIDR", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_networking.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_networking.k8s.io_v1_patched.json new file mode 100644 index 00000000..56d3c164 --- /dev/null +++ b/gen/openapi_v1/specs/apis_networking.k8s.io_v1_patched.json @@ -0,0 +1,9613 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.TypedLocalObjectReference": { + "description": "TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.", + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.networking.v1.HTTPIngressPath": { + "description": "HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend.", + "properties": { + "backend": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressBackend" + }, + "path": { + "description": "path is matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a '/' and must be present when using PathType with value \"Exact\" or \"Prefix\".", + "type": "string" + }, + "pathType": { + "description": "pathType determines the interpretation of the path matching. PathType can be one of the following values: * Exact: Matches the URL path exactly. * Prefix: Matches based on a URL path prefix split by '/'. Matching is\n done on a path element by element basis. A path element refers is the\n list of labels in the path split by the '/' separator. A request is a\n match for path p if every p is an element-wise prefix of p of the\n request path. Note that if the last element of the path is a substring\n of the last element in request path, it is not a match (e.g. /foo/bar\n matches /foo/bar/baz, but does not match /foo/barbaz).\n* ImplementationSpecific: Interpretation of the Path matching is up to\n the IngressClass. Implementations can treat this as a separate PathType\n or treat it identically to Prefix or Exact path types.\nImplementations are required to support all path types.", + "type": "string" + } + }, + "required": [ + "pathType", + "backend" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.HTTPIngressRuleValue": { + "description": "HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'.", + "properties": { + "paths": { + "description": "paths is a collection of paths that map requests to backends.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "paths" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IPAddress": { + "description": "IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressSpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IPAddressList": { + "description": "IPAddressList contains a list of IPAddress.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of IPAddresses.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IPAddressList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IPAddressSpec": { + "description": "IPAddressSpec describe the attributes in an IP Address.", + "properties": { + "parentRef": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ParentReference" + } + }, + "required": [ + "parentRef" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IPBlock": { + "description": "IPBlock describes a particular CIDR (Ex. \"192.168.1.0/24\",\"2001:db8::/64\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.", + "properties": { + "cidr": { + "default": "", + "description": "cidr is a string representing the IPBlock Valid examples are \"192.168.1.0/24\" or \"2001:db8::/64\"", + "type": "string" + }, + "except": { + "description": "except is a slice of CIDRs that should not be included within an IPBlock Valid examples are \"192.168.1.0/24\" or \"2001:db8::/64\" Except values will be rejected if they are outside the cidr range", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "cidr" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.Ingress": { + "description": "Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressBackend": { + "description": "IngressBackend describes all endpoints for a given service and port.", + "properties": { + "resource": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + }, + "service": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressClass": { + "description": "IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassSpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressClassList": { + "description": "IngressClassList is a collection of IngressClasses.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of IngressClasses.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressClassParametersReference": { + "description": "IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource.", + "properties": { + "apiGroup": { + "description": "apiGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the type of resource being referenced.", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the name of resource being referenced.", + "type": "string" + }, + "namespace": { + "description": "namespace is the namespace of the resource being referenced. This field is required when scope is set to \"Namespace\" and must be unset when scope is set to \"Cluster\".", + "type": "string" + }, + "scope": { + "description": "scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\".", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressClassSpec": { + "description": "IngressClassSpec provides information about the class of an Ingress.", + "properties": { + "controller": { + "description": "controller refers to the name of the controller that should handle this class. This allows for different \"flavors\" that are controlled by the same controller. For example, you may have different parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. \"acme.io/ingress-controller\". This field is immutable.", + "type": "string" + }, + "parameters": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressList": { + "description": "IngressList is a collection of Ingress.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of Ingress.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "IngressList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.IngressLoadBalancerIngress": { + "description": "IngressLoadBalancerIngress represents the status of a load-balancer ingress point.", + "properties": { + "hostname": { + "description": "hostname is set for load-balancer ingress points that are DNS based.", + "type": "string" + }, + "ip": { + "description": "ip is set for load-balancer ingress points that are IP based.", + "type": "string" + }, + "ports": { + "description": "ports provides information about the ports exposed by this LoadBalancer.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressPortStatus" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressLoadBalancerStatus": { + "description": "IngressLoadBalancerStatus represents the status of a load-balancer.", + "properties": { + "ingress": { + "description": "ingress is a list containing ingress points for the load-balancer.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressPortStatus": { + "description": "IngressPortStatus represents the error condition of a service port", + "properties": { + "error": { + "description": "error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\n CamelCase names\n- cloud provider specific error values must have names that comply with the\n format foo.example.com/CamelCase.", + "type": "string" + }, + "port": { + "default": 0, + "description": "port is the port number of the ingress port.", + "format": "int32", + "type": "integer" + }, + "protocol": { + "default": "", + "description": "protocol is the protocol of the ingress port. The supported values are: \"TCP\", \"UDP\", \"SCTP\"", + "type": "string" + } + }, + "required": [ + "port", + "protocol" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressRule": { + "description": "IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue.", + "properties": { + "host": { + "description": "host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to\n the IP in the Spec of the parent Ingress.\n2. The `:` delimiter is not respected because ports are not allowed.\n\t Currently the port of an Ingress is implicitly :80 for http and\n\t :443 for https.\nBoth these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue.\n\nhost can be \"precise\" which is a domain name without the terminating dot of a network host (e.g. \"foo.bar.com\") or \"wildcard\", which is a domain name prefixed with a single wildcard label (e.g. \"*.foo.com\"). The wildcard character '*' must appear by itself as the first DNS label and matches only a single label. You cannot have a wildcard label by itself (e.g. Host == \"*\"). Requests will be matched against the Host field in the following way: 1. If host is precise, the request matches this rule if the http host header is equal to Host. 2. If host is a wildcard, then the request matches this rule if the http host header is to equal to the suffix (removing the first label) of the wildcard rule.", + "type": "string" + }, + "http": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressServiceBackend": { + "description": "IngressServiceBackend references a Kubernetes Service as a Backend.", + "properties": { + "name": { + "default": "", + "description": "name is the referenced service. The service must exist in the same namespace as the Ingress object.", + "type": "string" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort" + } + }, + "required": [ + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.IngressSpec": { + "description": "IngressSpec describes the Ingress the user wishes to exist.", + "properties": { + "defaultBackend": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressBackend" + }, + "ingressClassName": { + "description": "ingressClassName is the name of an IngressClass cluster resource. Ingress controller implementations use this field to know whether they should be serving this Ingress resource, by a transitive connection (controller -> IngressClass -> Ingress resource). Although the `kubernetes.io/ingress.class` annotation (simple constant name) was never formally defined, it was widely supported by Ingress controllers to create a direct binding between Ingress controller and Ingress resources. Newly created Ingress resources should prefer using the field. However, even though the annotation is officially deprecated, for backwards compatibility reasons, ingress controllers should still honor that annotation if present.", + "type": "string" + }, + "rules": { + "description": "rules is a list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "tls": { + "description": "tls represents the TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressTLS" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressStatus": { + "description": "IngressStatus describe the current state of the Ingress.", + "properties": { + "loadBalancer": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.IngressTLS": { + "description": "IngressTLS describes the transport layer security associated with an ingress.", + "properties": { + "hosts": { + "description": "hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "secretName": { + "description": "secretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the \"Host\" header is used for routing.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicy": { + "description": "NetworkPolicy describes what network traffic is allowed for a set of Pods", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.NetworkPolicyEgressRule": { + "description": "NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8", + "properties": { + "ports": { + "description": "ports is a list of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "to": { + "description": "to is a list of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyIngressRule": { + "description": "NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from.", + "properties": { + "from": { + "description": "from is a list of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ports": { + "description": "ports is a list of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyList": { + "description": "NetworkPolicyList is a list of NetworkPolicy objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "NetworkPolicyList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.NetworkPolicyPeer": { + "description": "NetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed", + "properties": { + "ipBlock": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPBlock" + }, + "namespaceSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "podSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicyPort": { + "description": "NetworkPolicyPort describes a port to allow traffic on", + "properties": { + "endPort": { + "description": "endPort indicates that the range of ports from port to endPort if set, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port.", + "format": "int32", + "type": "integer" + }, + "port": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "protocol": { + "description": "protocol represents the protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.NetworkPolicySpec": { + "description": "NetworkPolicySpec provides the specification of a NetworkPolicy", + "properties": { + "egress": { + "description": "egress is a list of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "ingress": { + "description": "ingress is a list of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default)", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "podSelector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "policyTypes": { + "description": "policyTypes is a list of rule types that the NetworkPolicy relates to. Valid options are [\"Ingress\"], [\"Egress\"], or [\"Ingress\", \"Egress\"]. If this field is not specified, it will default based on the existence of ingress or egress rules; policies that contain an egress section are assumed to affect egress, and all policies (whether or not they contain an ingress section) are assumed to affect ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.ParentReference": { + "description": "ParentReference describes a reference to a parent object.", + "properties": { + "group": { + "description": "Group is the group of the object being referenced.", + "type": "string" + }, + "name": { + "description": "Name is the name of the object being referenced.", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of the object being referenced.", + "type": "string" + }, + "resource": { + "description": "Resource is the resource of the object being referenced.", + "type": "string" + } + }, + "required": [ + "resource", + "name" + ], + "type": "object" + }, + "io.k8s.api.networking.v1.ServiceBackendPort": { + "description": "ServiceBackendPort is the service port being referenced.", + "properties": { + "name": { + "description": "name is the name of the port on the Service. This is a mutually exclusive setting with \"Number\".", + "type": "string" + }, + "number": { + "description": "number is the numerical port number (e.g. 80) on the Service. This is a mutually exclusive setting with \"Name\".", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.networking.v1.ServiceCIDR": { + "description": "ServiceCIDR defines a range of IP addresses using CIDR format (e.g. 192.168.0.0/24 or 2001:db2::/64). This range is used to allocate ClusterIPs to Service objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.ServiceCIDRList": { + "description": "ServiceCIDRList contains a list of ServiceCIDR objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of ServiceCIDRs.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "networking.k8s.io", + "kind": "ServiceCIDRList", + "version": "v1" + } + ] + }, + "io.k8s.api.networking.v1.ServiceCIDRSpec": { + "description": "ServiceCIDRSpec define the CIDRs the user wants to use for allocating ClusterIPs for Services.", + "properties": { + "cidrs": { + "description": "CIDRs defines the IP blocks in CIDR notation (e.g. \"192.168.0.0/24\" or \"2001:db8::/64\") from which to assign service cluster IPs. Max of two CIDRs is allowed, one of each IP family. This field is immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.networking.v1.ServiceCIDRStatus": { + "description": "ServiceCIDRStatus describes the current state of the ServiceCIDR.", + "properties": { + "conditions": { + "description": "conditions holds an array of metav1.Condition that describe the state of the ServiceCIDR. Current service state", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/networking.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getNetworkingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ] + } + }, + "/apis/networking.k8s.io/v1/ingressclasses": { + "delete": { + "description": "delete collection of IngressClass", + "operationId": "deleteNetworkingV1CollectionIngressClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind IngressClass", + "operationId": "listNetworkingV1IngressClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an IngressClass", + "operationId": "createNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ingressclasses/{name}": { + "delete": { + "description": "delete an IngressClass", + "operationId": "deleteNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified IngressClass", + "operationId": "readNetworkingV1IngressClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the IngressClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified IngressClass", + "operationId": "patchNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified IngressClass", + "operationId": "replaceNetworkingV1IngressClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ingresses": { + "get": { + "description": "list or watch objects of kind Ingress", + "operationId": "listNetworkingV1IngressForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/ipaddresses": { + "delete": { + "description": "delete collection of IPAddress", + "operationId": "deleteNetworkingV1CollectionIPAddress", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind IPAddress", + "operationId": "listNetworkingV1IPAddress", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an IPAddress", + "operationId": "createNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/ipaddresses/{name}": { + "delete": { + "description": "delete an IPAddress", + "operationId": "deleteNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "get": { + "description": "read the specified IPAddress", + "operationId": "readNetworkingV1IPAddress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the IPAddress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified IPAddress", + "operationId": "patchNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "put": { + "description": "replace the specified IPAddress", + "operationId": "replaceNetworkingV1IPAddress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IPAddress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses": { + "delete": { + "description": "delete collection of Ingress", + "operationId": "deleteNetworkingV1CollectionNamespacedIngress", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Ingress", + "operationId": "listNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.IngressList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create an Ingress", + "operationId": "createNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}": { + "delete": { + "description": "delete an Ingress", + "operationId": "deleteNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "get": { + "description": "read the specified Ingress", + "operationId": "readNetworkingV1NamespacedIngress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Ingress", + "operationId": "patchNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Ingress", + "operationId": "replaceNetworkingV1NamespacedIngress", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status": { + "get": { + "description": "read status of the specified Ingress", + "operationId": "readNetworkingV1NamespacedIngressStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified Ingress", + "operationId": "patchNetworkingV1NamespacedIngressStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified Ingress", + "operationId": "replaceNetworkingV1NamespacedIngressStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.Ingress" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies": { + "delete": { + "description": "delete collection of NetworkPolicy", + "operationId": "deleteNetworkingV1CollectionNamespacedNetworkPolicy", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind NetworkPolicy", + "operationId": "listNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a NetworkPolicy", + "operationId": "createNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}": { + "delete": { + "description": "delete a NetworkPolicy", + "operationId": "deleteNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "get": { + "description": "read the specified NetworkPolicy", + "operationId": "readNetworkingV1NamespacedNetworkPolicy", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the NetworkPolicy", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified NetworkPolicy", + "operationId": "patchNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "put": { + "description": "replace the specified NetworkPolicy", + "operationId": "replaceNetworkingV1NamespacedNetworkPolicy", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/networkpolicies": { + "get": { + "description": "list or watch objects of kind NetworkPolicy", + "operationId": "listNetworkingV1NetworkPolicyForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/servicecidrs": { + "delete": { + "description": "delete collection of ServiceCIDR", + "operationId": "deleteNetworkingV1CollectionServiceCIDR", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ServiceCIDR", + "operationId": "listNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ServiceCIDR", + "operationId": "createNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/servicecidrs/{name}": { + "delete": { + "description": "delete a ServiceCIDR", + "operationId": "deleteNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "get": { + "description": "read the specified ServiceCIDR", + "operationId": "readNetworkingV1ServiceCIDR", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ServiceCIDR", + "operationId": "patchNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ServiceCIDR", + "operationId": "replaceNetworkingV1ServiceCIDR", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/servicecidrs/{name}/status": { + "get": { + "description": "read status of the specified ServiceCIDR", + "operationId": "readNetworkingV1ServiceCIDRStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified ServiceCIDR", + "operationId": "patchNetworkingV1ServiceCIDRStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified ServiceCIDR", + "operationId": "replaceNetworkingV1ServiceCIDRStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + } + }, + "/apis/networking.k8s.io/v1/watch/ingressclasses": { + "get": { + "description": "watch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IngressClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ingressclasses/{name}": { + "get": { + "description": "watch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1IngressClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IngressClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the IngressClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ingresses": { + "get": { + "description": "watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IngressListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ipaddresses": { + "get": { + "description": "watch individual changes to a list of IPAddress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1IPAddressList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/ipaddresses/{name}": { + "get": { + "description": "watch changes to an object of kind IPAddress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1IPAddress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "IPAddress", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the IPAddress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses": { + "get": { + "description": "watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NamespacedIngressList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}": { + "get": { + "description": "watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1NamespacedIngress", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "Ingress", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Ingress", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies": { + "get": { + "description": "watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NamespacedNetworkPolicyList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}": { + "get": { + "description": "watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1NamespacedNetworkPolicy", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the NetworkPolicy", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/networkpolicies": { + "get": { + "description": "watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1NetworkPolicyListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "NetworkPolicy", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/servicecidrs": { + "get": { + "description": "watch individual changes to a list of ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNetworkingV1ServiceCIDRList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/networking.k8s.io/v1/watch/servicecidrs/{name}": { + "get": { + "description": "watch changes to an object of kind ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNetworkingV1ServiceCIDR", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "networking_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "networking.k8s.io", + "kind": "ServiceCIDR", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ServiceCIDR", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_node.k8s.io_v1.json b/gen/openapi_v1/specs/apis_node.k8s.io_v1.json new file mode 100644 index 00000000..08fd5417 --- /dev/null +++ b/gen/openapi_v1/specs/apis_node.k8s.io_v1.json @@ -0,0 +1,2640 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.node.v1.Overhead": { + "description": "Overhead structure represents the resource overhead associated with running a pod.", + "properties": { + "podFixed": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "podFixed represents the fixed resource overhead associated with running a pod.", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.node.v1.RuntimeClass": { + "description": "RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "handler": { + "default": "", + "description": "handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called \"runc\" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "overhead": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.node.v1.Overhead" + } + ], + "description": "overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see\n https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/" + }, + "scheduling": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.node.v1.Scheduling" + } + ], + "description": "scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes." + } + }, + "required": [ + "handler" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + ] + }, + "io.k8s.api.node.v1.RuntimeClassList": { + "description": "RuntimeClassList is a list of RuntimeClass objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "node.k8s.io", + "kind": "RuntimeClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.node.v1.Scheduling": { + "description": "Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.", + "properties": { + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "tolerations": { + "description": "tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/node.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getNodeV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ] + } + }, + "/apis/node.k8s.io/v1/runtimeclasses": { + "delete": { + "description": "delete collection of RuntimeClass", + "operationId": "deleteNodeV1CollectionRuntimeClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind RuntimeClass", + "operationId": "listNodeV1RuntimeClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a RuntimeClass", + "operationId": "createNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + } + }, + "/apis/node.k8s.io/v1/runtimeclasses/{name}": { + "delete": { + "description": "delete a RuntimeClass", + "operationId": "deleteNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified RuntimeClass", + "operationId": "readNodeV1RuntimeClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the RuntimeClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified RuntimeClass", + "operationId": "patchNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified RuntimeClass", + "operationId": "replaceNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + } + }, + "/apis/node.k8s.io/v1/watch/runtimeclasses": { + "get": { + "description": "watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNodeV1RuntimeClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/node.k8s.io/v1/watch/runtimeclasses/{name}": { + "get": { + "description": "watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNodeV1RuntimeClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the RuntimeClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_node.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_node.k8s.io_v1_patched.json new file mode 100644 index 00000000..282b6e89 --- /dev/null +++ b/gen/openapi_v1/specs/apis_node.k8s.io_v1_patched.json @@ -0,0 +1,2564 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.Toleration": { + "description": "The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .", + "properties": { + "effect": { + "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.", + "type": "string" + }, + "key": { + "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.", + "type": "string" + }, + "operator": { + "description": "Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).", + "type": "string" + }, + "tolerationSeconds": { + "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.", + "format": "int64", + "type": "integer" + }, + "value": { + "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.node.v1.Overhead": { + "description": "Overhead structure represents the resource overhead associated with running a pod.", + "properties": { + "podFixed": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "podFixed represents the fixed resource overhead associated with running a pod.", + "type": "object" + } + }, + "type": "object" + }, + "io.k8s.api.node.v1.RuntimeClass": { + "description": "RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "handler": { + "default": "", + "description": "handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called \"runc\" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "overhead": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.Overhead" + }, + "scheduling": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.Scheduling" + } + }, + "required": [ + "handler" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + ] + }, + "io.k8s.api.node.v1.RuntimeClassList": { + "description": "RuntimeClassList is a list of RuntimeClass objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is a list of schema objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "node.k8s.io", + "kind": "RuntimeClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.node.v1.Scheduling": { + "description": "Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.", + "properties": { + "nodeSelector": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.", + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "tolerations": { + "description": "tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.Toleration" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/node.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getNodeV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ] + } + }, + "/apis/node.k8s.io/v1/runtimeclasses": { + "delete": { + "description": "delete collection of RuntimeClass", + "operationId": "deleteNodeV1CollectionRuntimeClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind RuntimeClass", + "operationId": "listNodeV1RuntimeClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a RuntimeClass", + "operationId": "createNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + } + }, + "/apis/node.k8s.io/v1/runtimeclasses/{name}": { + "delete": { + "description": "delete a RuntimeClass", + "operationId": "deleteNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified RuntimeClass", + "operationId": "readNodeV1RuntimeClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the RuntimeClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified RuntimeClass", + "operationId": "patchNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified RuntimeClass", + "operationId": "replaceNodeV1RuntimeClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.node.v1.RuntimeClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + } + }, + "/apis/node.k8s.io/v1/watch/runtimeclasses": { + "get": { + "description": "watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchNodeV1RuntimeClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/node.k8s.io/v1/watch/runtimeclasses/{name}": { + "get": { + "description": "watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchNodeV1RuntimeClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "node_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "node.k8s.io", + "kind": "RuntimeClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the RuntimeClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_policy_v1.json b/gen/openapi_v1/specs/apis_policy_v1.json new file mode 100644 index 00000000..bd1134c9 --- /dev/null +++ b/gen/openapi_v1/specs/apis_policy_v1.json @@ -0,0 +1,3452 @@ +{ + "components": { + "schemas": { + "io.k8s.api.policy.v1.PodDisruptionBudget": { + "description": "PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec" + } + ], + "default": {}, + "description": "Specification of the desired behavior of the PodDisruptionBudget." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus" + } + ], + "default": {}, + "description": "Most recently observed status of the PodDisruptionBudget." + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + ] + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetList": { + "description": "PodDisruptionBudgetList is a collection of PodDisruptionBudgets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of PodDisruptionBudgets", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "PodDisruptionBudgetList", + "version": "v1" + } + ] + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetSpec": { + "description": "PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.", + "properties": { + "maxUnavailable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\"." + }, + "minAvailable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + } + ], + "description": "An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\"." + }, + "selector": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.", + "x-kubernetes-patch-strategy": "replace" + }, + "unhealthyPodEvictionPolicy": { + "description": "UnhealthyPodEvictionPolicy defines the criteria for when unhealthy pods should be considered for eviction. Current implementation considers healthy pods, as pods that have status.conditions item with type=\"Ready\",status=\"True\".\n\nValid policies are IfHealthyBudget and AlwaysAllow. If no policy is specified, the default behavior will be used, which corresponds to the IfHealthyBudget policy.\n\nIfHealthyBudget policy means that running pods (status.phase=\"Running\"), but not yet healthy can be evicted only if the guarded application is not disrupted (status.currentHealthy is at least equal to status.desiredHealthy). Healthy pods will be subject to the PDB for eviction.\n\nAlwaysAllow policy means that all running pods (status.phase=\"Running\"), but not yet healthy are considered disrupted and can be evicted regardless of whether the criteria in a PDB is met. This means perspective running pods of a disrupted application might not get a chance to become healthy. Healthy pods will be subject to the PDB for eviction.\n\nAdditional policies may be added in the future. Clients making eviction decisions should disallow eviction of unhealthy pods if they encounter an unrecognized policy in this field.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetStatus": { + "description": "PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.", + "properties": { + "conditions": { + "description": "Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute\n the number of allowed disruptions. Therefore no disruptions are\n allowed and the status of the condition will be False.\n- InsufficientPods: The number of pods are either at or below the number\n required by the PodDisruptionBudget. No disruptions are\n allowed and the status of the condition will be False.\n- SufficientPods: There are more pods than required by the PodDisruptionBudget.\n The condition will be True, and the number of allowed\n disruptions are provided by the disruptionsAllowed property.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge" + }, + "currentHealthy": { + "default": 0, + "description": "current number of healthy pods", + "format": "int32", + "type": "integer" + }, + "desiredHealthy": { + "default": 0, + "description": "minimum desired number of healthy pods", + "format": "int32", + "type": "integer" + }, + "disruptedPods": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "description": "DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions.", + "type": "object" + }, + "disruptionsAllowed": { + "default": 0, + "description": "Number of pod disruptions that are currently allowed.", + "format": "int32", + "type": "integer" + }, + "expectedPods": { + "default": 0, + "description": "total number of pods counted by this disruption budget", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "Most recent generation observed when updating this PDB status. DisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "disruptionsAllowed", + "currentHealthy", + "desiredHealthy", + "expectedPods" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable." + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/policy/v1/": { + "get": { + "description": "get available resources", + "operationId": "getPolicyV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ] + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets": { + "delete": { + "description": "delete collection of PodDisruptionBudget", + "operationId": "deletePolicyV1CollectionNamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PodDisruptionBudget", + "operationId": "listPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PodDisruptionBudget", + "operationId": "createPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}": { + "delete": { + "description": "delete a PodDisruptionBudget", + "operationId": "deletePolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "get": { + "description": "read the specified PodDisruptionBudget", + "operationId": "readPolicyV1NamespacedPodDisruptionBudget", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PodDisruptionBudget", + "operationId": "patchPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PodDisruptionBudget", + "operationId": "replacePolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status": { + "get": { + "description": "read status of the specified PodDisruptionBudget", + "operationId": "readPolicyV1NamespacedPodDisruptionBudgetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PodDisruptionBudget", + "operationId": "patchPolicyV1NamespacedPodDisruptionBudgetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PodDisruptionBudget", + "operationId": "replacePolicyV1NamespacedPodDisruptionBudgetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/poddisruptionbudgets": { + "get": { + "description": "list or watch objects of kind PodDisruptionBudget", + "operationId": "listPolicyV1PodDisruptionBudgetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets": { + "get": { + "description": "watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchPolicyV1NamespacedPodDisruptionBudgetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}": { + "get": { + "description": "watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchPolicyV1NamespacedPodDisruptionBudget", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/poddisruptionbudgets": { + "get": { + "description": "watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchPolicyV1PodDisruptionBudgetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_policy_v1_patched.json b/gen/openapi_v1/specs/apis_policy_v1_patched.json new file mode 100644 index 00000000..20f74925 --- /dev/null +++ b/gen/openapi_v1/specs/apis_policy_v1_patched.json @@ -0,0 +1,3350 @@ +{ + "components": { + "schemas": { + "io.k8s.api.policy.v1.PodDisruptionBudget": { + "description": "PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + ] + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetList": { + "description": "PodDisruptionBudgetList is a collection of PodDisruptionBudgets.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of PodDisruptionBudgets", + "items": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "policy", + "kind": "PodDisruptionBudgetList", + "version": "v1" + } + ] + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetSpec": { + "description": "PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.", + "properties": { + "maxUnavailable": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "minAvailable": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString" + }, + "selector": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "unhealthyPodEvictionPolicy": { + "description": "UnhealthyPodEvictionPolicy defines the criteria for when unhealthy pods should be considered for eviction. Current implementation considers healthy pods, as pods that have status.conditions item with type=\"Ready\",status=\"True\".\n\nValid policies are IfHealthyBudget and AlwaysAllow. If no policy is specified, the default behavior will be used, which corresponds to the IfHealthyBudget policy.\n\nIfHealthyBudget policy means that running pods (status.phase=\"Running\"), but not yet healthy can be evicted only if the guarded application is not disrupted (status.currentHealthy is at least equal to status.desiredHealthy). Healthy pods will be subject to the PDB for eviction.\n\nAlwaysAllow policy means that all running pods (status.phase=\"Running\"), but not yet healthy are considered disrupted and can be evicted regardless of whether the criteria in a PDB is met. This means perspective running pods of a disrupted application might not get a chance to become healthy. Healthy pods will be subject to the PDB for eviction.\n\nAdditional policies may be added in the future. Clients making eviction decisions should disallow eviction of unhealthy pods if they encounter an unrecognized policy in this field.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.policy.v1.PodDisruptionBudgetStatus": { + "description": "PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.", + "properties": { + "conditions": { + "description": "Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute\n the number of allowed disruptions. Therefore no disruptions are\n allowed and the status of the condition will be False.\n- InsufficientPods: The number of pods are either at or below the number\n required by the PodDisruptionBudget. No disruptions are\n allowed and the status of the condition will be False.\n- SufficientPods: There are more pods than required by the PodDisruptionBudget.\n The condition will be True, and the number of allowed\n disruptions are provided by the disruptionsAllowed property.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "type", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "currentHealthy": { + "default": 0, + "description": "current number of healthy pods", + "format": "int32", + "type": "integer" + }, + "desiredHealthy": { + "default": 0, + "description": "minimum desired number of healthy pods", + "format": "int32", + "type": "integer" + }, + "disruptedPods": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "description": "DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions.", + "type": "object" + }, + "disruptionsAllowed": { + "default": 0, + "description": "Number of pod disruptions that are currently allowed.", + "format": "int32", + "type": "integer" + }, + "expectedPods": { + "default": 0, + "description": "total number of pods counted by this disruption budget", + "format": "int32", + "type": "integer" + }, + "observedGeneration": { + "description": "Most recent generation observed when updating this PDB status. DisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation.", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "disruptionsAllowed", + "currentHealthy", + "desiredHealthy", + "expectedPods" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Condition": { + "description": "Condition contains details for one aspect of the current state of this API Resource.", + "properties": { + "lastTransitionTime": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "message": { + "default": "", + "description": "message is a human readable message indicating details about the transition. This may be an empty string.", + "type": "string" + }, + "observedGeneration": { + "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.", + "format": "int64", + "type": "integer" + }, + "reason": { + "default": "", + "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.", + "type": "string" + }, + "status": { + "default": "", + "description": "status of the condition, one of True, False, Unknown.", + "type": "string" + }, + "type": { + "default": "", + "description": "type of condition in CamelCase or in foo.example.com/CamelCase.", + "type": "string" + } + }, + "required": [ + "type", + "status", + "lastTransitionTime", + "reason", + "message" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.util.intstr.IntOrString": { + "description": "IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.", + "format": "int-or-string", + "oneOf": [ + { + "type": "integer" + }, + { + "type": "string" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/policy/v1/": { + "get": { + "description": "get available resources", + "operationId": "getPolicyV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ] + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets": { + "delete": { + "description": "delete collection of PodDisruptionBudget", + "operationId": "deletePolicyV1CollectionNamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PodDisruptionBudget", + "operationId": "listPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PodDisruptionBudget", + "operationId": "createPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}": { + "delete": { + "description": "delete a PodDisruptionBudget", + "operationId": "deletePolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "get": { + "description": "read the specified PodDisruptionBudget", + "operationId": "readPolicyV1NamespacedPodDisruptionBudget", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PodDisruptionBudget", + "operationId": "patchPolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PodDisruptionBudget", + "operationId": "replacePolicyV1NamespacedPodDisruptionBudget", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status": { + "get": { + "description": "read status of the specified PodDisruptionBudget", + "operationId": "readPolicyV1NamespacedPodDisruptionBudgetStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified PodDisruptionBudget", + "operationId": "patchPolicyV1NamespacedPodDisruptionBudgetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified PodDisruptionBudget", + "operationId": "replacePolicyV1NamespacedPodDisruptionBudgetStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + } + }, + "/apis/policy/v1/poddisruptionbudgets": { + "get": { + "description": "list or watch objects of kind PodDisruptionBudget", + "operationId": "listPolicyV1PodDisruptionBudgetForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets": { + "get": { + "description": "watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchPolicyV1NamespacedPodDisruptionBudgetList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}": { + "get": { + "description": "watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchPolicyV1NamespacedPodDisruptionBudget", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PodDisruptionBudget", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/policy/v1/watch/poddisruptionbudgets": { + "get": { + "description": "watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchPolicyV1PodDisruptionBudgetListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "policy_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "policy", + "kind": "PodDisruptionBudget", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1.json b/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1.json new file mode 100644 index 00000000..525506b4 --- /dev/null +++ b/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1.json @@ -0,0 +1,7449 @@ +{ + "components": { + "schemas": { + "io.k8s.api.rbac.v1.AggregationRule": { + "description": "AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole", + "properties": { + "clusterRoleSelectors": { + "description": "ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.rbac.v1.ClusterRole": { + "description": "ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.", + "properties": { + "aggregationRule": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.AggregationRule" + } + ], + "description": "AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller." + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + }, + "rules": { + "description": "Rules holds all the PolicyRules for this ClusterRole", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.PolicyRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleBinding": { + "description": "ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + }, + "roleRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleRef" + } + ], + "default": {}, + "description": "RoleRef can only reference a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error. This field is immutable." + }, + "subjects": { + "description": "Subjects holds references to the objects the role applies to.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Subject" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "roleRef" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleBindingList": { + "description": "ClusterRoleBindingList is a collection of ClusterRoleBindings", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ClusterRoleBindings", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBindingList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleList": { + "description": "ClusterRoleList is a collection of ClusterRoles", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ClusterRoles", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.PolicyRule": { + "description": "PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.", + "properties": { + "apiGroups": { + "description": "APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"\" represents the core API group and \"*\" represents all API groups.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "nonResourceURLs": { + "description": "NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resourceNames": { + "description": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "resources": { + "description": "Resources is a list of resources this rule applies to. '*' represents all resources.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "verbs": { + "description": "Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "verbs" + ], + "type": "object" + }, + "io.k8s.api.rbac.v1.Role": { + "description": "Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + }, + "rules": { + "description": "Rules holds all the PolicyRules for this Role", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.PolicyRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleBinding": { + "description": "RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + }, + "roleRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleRef" + } + ], + "default": {}, + "description": "RoleRef can reference a Role in the current namespace or a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error. This field is immutable." + }, + "subjects": { + "description": "Subjects holds references to the objects the role applies to.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Subject" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "roleRef" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleBindingList": { + "description": "RoleBindingList is a collection of RoleBindings", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of RoleBindings", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBindingList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleList": { + "description": "RoleList is a collection of Roles", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of Roles", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard object's metadata." + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleRef": { + "description": "RoleRef contains information that points to the role being used", + "properties": { + "apiGroup": { + "default": "", + "description": "APIGroup is the group for the resource being referenced", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "apiGroup", + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.rbac.v1.Subject": { + "description": "Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names.", + "properties": { + "apiGroup": { + "description": "APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the object being referenced.", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/rbac.authorization.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getRbacAuthorizationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ] + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings": { + "delete": { + "description": "delete collection of ClusterRoleBinding", + "operationId": "deleteRbacAuthorizationV1CollectionClusterRoleBinding", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ClusterRoleBinding", + "operationId": "listRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ClusterRoleBinding", + "operationId": "createRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}": { + "delete": { + "description": "delete a ClusterRoleBinding", + "operationId": "deleteRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "get": { + "description": "read the specified ClusterRoleBinding", + "operationId": "readRbacAuthorizationV1ClusterRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ClusterRoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ClusterRoleBinding", + "operationId": "patchRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ClusterRoleBinding", + "operationId": "replaceRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterroles": { + "delete": { + "description": "delete collection of ClusterRole", + "operationId": "deleteRbacAuthorizationV1CollectionClusterRole", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ClusterRole", + "operationId": "listRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ClusterRole", + "operationId": "createRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}": { + "delete": { + "description": "delete a ClusterRole", + "operationId": "deleteRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "get": { + "description": "read the specified ClusterRole", + "operationId": "readRbacAuthorizationV1ClusterRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the ClusterRole", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ClusterRole", + "operationId": "patchRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ClusterRole", + "operationId": "replaceRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings": { + "delete": { + "description": "delete collection of RoleBinding", + "operationId": "deleteRbacAuthorizationV1CollectionNamespacedRoleBinding", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind RoleBinding", + "operationId": "listRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a RoleBinding", + "operationId": "createRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}": { + "delete": { + "description": "delete a RoleBinding", + "operationId": "deleteRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "get": { + "description": "read the specified RoleBinding", + "operationId": "readRbacAuthorizationV1NamespacedRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the RoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified RoleBinding", + "operationId": "patchRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "put": { + "description": "replace the specified RoleBinding", + "operationId": "replaceRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles": { + "delete": { + "description": "delete collection of Role", + "operationId": "deleteRbacAuthorizationV1CollectionNamespacedRole", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Role", + "operationId": "listRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Role", + "operationId": "createRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}": { + "delete": { + "description": "delete a Role", + "operationId": "deleteRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "get": { + "description": "read the specified Role", + "operationId": "readRbacAuthorizationV1NamespacedRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the Role", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Role", + "operationId": "patchRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Role", + "operationId": "replaceRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/rolebindings": { + "get": { + "description": "list or watch objects of kind RoleBinding", + "operationId": "listRbacAuthorizationV1RoleBindingForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/roles": { + "get": { + "description": "list or watch objects of kind Role", + "operationId": "listRbacAuthorizationV1RoleForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings": { + "get": { + "description": "watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1ClusterRoleBindingList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}": { + "get": { + "description": "watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1ClusterRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ClusterRoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles": { + "get": { + "description": "watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1ClusterRoleList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}": { + "get": { + "description": "watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1ClusterRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ClusterRole", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings": { + "get": { + "description": "watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleBindingList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}": { + "get": { + "description": "watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the RoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles": { + "get": { + "description": "watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}": { + "get": { + "description": "watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1NamespacedRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Role", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/rolebindings": { + "get": { + "description": "watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1RoleBindingListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/roles": { + "get": { + "description": "watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1RoleListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1_patched.json new file mode 100644 index 00000000..b310316a --- /dev/null +++ b/gen/openapi_v1/specs/apis_rbac.authorization.k8s.io_v1_patched.json @@ -0,0 +1,7298 @@ +{ + "components": { + "schemas": { + "io.k8s.api.rbac.v1.AggregationRule": { + "description": "AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole", + "properties": { + "clusterRoleSelectors": { + "description": "ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.rbac.v1.ClusterRole": { + "description": "ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.", + "properties": { + "aggregationRule": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.AggregationRule" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "rules": { + "description": "Rules holds all the PolicyRules for this ClusterRole", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.PolicyRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleBinding": { + "description": "ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "roleRef": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleRef" + }, + "subjects": { + "description": "Subjects holds references to the objects the role applies to.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Subject" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "roleRef" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleBindingList": { + "description": "ClusterRoleBindingList is a collection of ClusterRoleBindings", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ClusterRoleBindings", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBindingList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.ClusterRoleList": { + "description": "ClusterRoleList is a collection of ClusterRoles", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of ClusterRoles", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.PolicyRule": { + "description": "PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.", + "properties": { + "apiGroups": { + "description": "APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"\" represents the core API group and \"*\" represents all API groups.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "nonResourceURLs": { + "description": "NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resourceNames": { + "description": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "resources": { + "description": "Resources is a list of resources this rule applies to. '*' represents all resources.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "verbs": { + "description": "Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "verbs" + ], + "type": "object" + }, + "io.k8s.api.rbac.v1.Role": { + "description": "Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "rules": { + "description": "Rules holds all the PolicyRules for this Role", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.PolicyRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleBinding": { + "description": "RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "roleRef": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleRef" + }, + "subjects": { + "description": "Subjects holds references to the objects the role applies to.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Subject" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "roleRef" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleBindingList": { + "description": "RoleBindingList is a collection of RoleBindings", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of RoleBindings", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBindingList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleList": { + "description": "RoleList is a collection of Roles", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "Items is a list of Roles", + "items": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "rbac.authorization.k8s.io", + "kind": "RoleList", + "version": "v1" + } + ] + }, + "io.k8s.api.rbac.v1.RoleRef": { + "description": "RoleRef contains information that points to the role being used", + "properties": { + "apiGroup": { + "default": "", + "description": "APIGroup is the group for the resource being referenced", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + } + }, + "required": [ + "apiGroup", + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.rbac.v1.Subject": { + "description": "Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names.", + "properties": { + "apiGroup": { + "description": "APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error.", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the object being referenced.", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/rbac.authorization.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getRbacAuthorizationV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ] + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings": { + "delete": { + "description": "delete collection of ClusterRoleBinding", + "operationId": "deleteRbacAuthorizationV1CollectionClusterRoleBinding", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ClusterRoleBinding", + "operationId": "listRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ClusterRoleBinding", + "operationId": "createRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}": { + "delete": { + "description": "delete a ClusterRoleBinding", + "operationId": "deleteRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "get": { + "description": "read the specified ClusterRoleBinding", + "operationId": "readRbacAuthorizationV1ClusterRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ClusterRoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ClusterRoleBinding", + "operationId": "patchRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ClusterRoleBinding", + "operationId": "replaceRbacAuthorizationV1ClusterRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterroles": { + "delete": { + "description": "delete collection of ClusterRole", + "operationId": "deleteRbacAuthorizationV1CollectionClusterRole", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind ClusterRole", + "operationId": "listRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a ClusterRole", + "operationId": "createRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}": { + "delete": { + "description": "delete a ClusterRole", + "operationId": "deleteRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "get": { + "description": "read the specified ClusterRole", + "operationId": "readRbacAuthorizationV1ClusterRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the ClusterRole", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified ClusterRole", + "operationId": "patchRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "put": { + "description": "replace the specified ClusterRole", + "operationId": "replaceRbacAuthorizationV1ClusterRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.ClusterRole" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings": { + "delete": { + "description": "delete collection of RoleBinding", + "operationId": "deleteRbacAuthorizationV1CollectionNamespacedRoleBinding", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind RoleBinding", + "operationId": "listRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a RoleBinding", + "operationId": "createRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}": { + "delete": { + "description": "delete a RoleBinding", + "operationId": "deleteRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "get": { + "description": "read the specified RoleBinding", + "operationId": "readRbacAuthorizationV1NamespacedRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the RoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified RoleBinding", + "operationId": "patchRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "put": { + "description": "replace the specified RoleBinding", + "operationId": "replaceRbacAuthorizationV1NamespacedRoleBinding", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBinding" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles": { + "delete": { + "description": "delete collection of Role", + "operationId": "deleteRbacAuthorizationV1CollectionNamespacedRole", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind Role", + "operationId": "listRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a Role", + "operationId": "createRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}": { + "delete": { + "description": "delete a Role", + "operationId": "deleteRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "get": { + "description": "read the specified Role", + "operationId": "readRbacAuthorizationV1NamespacedRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the Role", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified Role", + "operationId": "patchRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "put": { + "description": "replace the specified Role", + "operationId": "replaceRbacAuthorizationV1NamespacedRole", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.Role" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + } + }, + "/apis/rbac.authorization.k8s.io/v1/rolebindings": { + "get": { + "description": "list or watch objects of kind RoleBinding", + "operationId": "listRbacAuthorizationV1RoleBindingForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/roles": { + "get": { + "description": "list or watch objects of kind Role", + "operationId": "listRbacAuthorizationV1RoleForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.rbac.v1.RoleList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings": { + "get": { + "description": "watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1ClusterRoleBindingList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}": { + "get": { + "description": "watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1ClusterRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRoleBinding", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ClusterRoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles": { + "get": { + "description": "watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1ClusterRoleList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}": { + "get": { + "description": "watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1ClusterRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "ClusterRole", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the ClusterRole", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings": { + "get": { + "description": "watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleBindingList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}": { + "get": { + "description": "watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleBinding", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the RoleBinding", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles": { + "get": { + "description": "watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1NamespacedRoleList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}": { + "get": { + "description": "watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchRbacAuthorizationV1NamespacedRole", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the Role", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/rolebindings": { + "get": { + "description": "watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1RoleBindingListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "RoleBinding", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/rbac.authorization.k8s.io/v1/watch/roles": { + "get": { + "description": "watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchRbacAuthorizationV1RoleListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "rbacAuthorization_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "rbac.authorization.k8s.io", + "kind": "Role", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1.json b/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1.json new file mode 100644 index 00000000..20748542 --- /dev/null +++ b/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1.json @@ -0,0 +1,2558 @@ +{ + "components": { + "schemas": { + "io.k8s.api.scheduling.v1.PriorityClass": { + "description": "PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "description": { + "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "type": "string" + }, + "globalDefault": { + "description": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "preemptionPolicy": { + "description": "preemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "value": { + "default": 0, + "description": "value represents the integer value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "value" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + ] + }, + "io.k8s.api.scheduling.v1.PriorityClassList": { + "description": "PriorityClassList is a collection of priority classes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of PriorityClasses", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "scheduling.k8s.io", + "kind": "PriorityClassList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/scheduling.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getSchedulingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ] + } + }, + "/apis/scheduling.k8s.io/v1/priorityclasses": { + "delete": { + "description": "delete collection of PriorityClass", + "operationId": "deleteSchedulingV1CollectionPriorityClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PriorityClass", + "operationId": "listSchedulingV1PriorityClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PriorityClass", + "operationId": "createSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + } + }, + "/apis/scheduling.k8s.io/v1/priorityclasses/{name}": { + "delete": { + "description": "delete a PriorityClass", + "operationId": "deleteSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified PriorityClass", + "operationId": "readSchedulingV1PriorityClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the PriorityClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PriorityClass", + "operationId": "patchSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PriorityClass", + "operationId": "replaceSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + } + }, + "/apis/scheduling.k8s.io/v1/watch/priorityclasses": { + "get": { + "description": "watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchSchedulingV1PriorityClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}": { + "get": { + "description": "watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchSchedulingV1PriorityClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PriorityClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1_patched.json new file mode 100644 index 00000000..e7009b14 --- /dev/null +++ b/gen/openapi_v1/specs/apis_scheduling.k8s.io_v1_patched.json @@ -0,0 +1,2496 @@ +{ + "components": { + "schemas": { + "io.k8s.api.scheduling.v1.PriorityClass": { + "description": "PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "description": { + "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "type": "string" + }, + "globalDefault": { + "description": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "preemptionPolicy": { + "description": "preemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.", + "type": "string" + }, + "value": { + "default": 0, + "description": "value represents the integer value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", + "format": "int32", + "type": "integer" + } + }, + "required": [ + "value" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + ] + }, + "io.k8s.api.scheduling.v1.PriorityClassList": { + "description": "PriorityClassList is a collection of priority classes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of PriorityClasses", + "items": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "scheduling.k8s.io", + "kind": "PriorityClassList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/scheduling.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getSchedulingV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ] + } + }, + "/apis/scheduling.k8s.io/v1/priorityclasses": { + "delete": { + "description": "delete collection of PriorityClass", + "operationId": "deleteSchedulingV1CollectionPriorityClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind PriorityClass", + "operationId": "listSchedulingV1PriorityClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a PriorityClass", + "operationId": "createSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + } + }, + "/apis/scheduling.k8s.io/v1/priorityclasses/{name}": { + "delete": { + "description": "delete a PriorityClass", + "operationId": "deleteSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified PriorityClass", + "operationId": "readSchedulingV1PriorityClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the PriorityClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified PriorityClass", + "operationId": "patchSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified PriorityClass", + "operationId": "replaceSchedulingV1PriorityClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + } + }, + "/apis/scheduling.k8s.io/v1/watch/priorityclasses": { + "get": { + "description": "watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchSchedulingV1PriorityClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}": { + "get": { + "description": "watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchSchedulingV1PriorityClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "scheduling_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "scheduling.k8s.io", + "kind": "PriorityClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the PriorityClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_storage.k8s.io_v1.json b/gen/openapi_v1/specs/apis_storage.k8s.io_v1.json new file mode 100644 index 00000000..6212f1d5 --- /dev/null +++ b/gen/openapi_v1/specs/apis_storage.k8s.io_v1.json @@ -0,0 +1,11408 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFilePersistentVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "secretNamespace": { + "description": "secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure Share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIPersistentVolumeSource": { + "description": "Represents storage that is managed by an external CSI volume driver", + "properties": { + "controllerExpandSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "controllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "controllerPublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "controllerPublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerPublishVolume and ControllerUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume. Required.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\".", + "type": "string" + }, + "nodeExpandSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodeExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeExpandVolume call. This field is optional, may be omitted if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "nodePublishSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "nodeStageSecretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "nodeStageSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeStageVolume and NodeStageVolume and NodeUnstageVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed." + }, + "readOnly": { + "description": "readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes of the volume to publish.", + "type": "object" + }, + "volumeHandle": { + "default": "", + "description": "volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.", + "type": "string" + } + }, + "required": [ + "driver", + "volumeHandle" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CephFSPersistentVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it" + }, + "user": { + "description": "user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderPersistentVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: points to a secret object containing parameters used to connect to OpenStack." + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FlexPersistentVolumeSource": { + "description": "FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is Optional: SecretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts." + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsPersistentVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "endpointsNamespace": { + "description": "endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIPersistentVolumeSource": { + "description": "ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is Target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun is iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is the CHAP Secret for iSCSI target and initiator authentication" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LocalVolumeSource": { + "description": "Local represents directly-attached storage with node affinity", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a filesystem if unspecified.", + "type": "string" + }, + "path": { + "default": "", + "description": "path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeSpec": { + "description": "PersistentVolumeSpec is the specification of a persistent volume.", + "properties": { + "accessModes": { + "description": "accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "awsElasticBlockStore": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + } + ], + "description": "awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore" + }, + "azureDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + } + ], + "description": "azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver." + }, + "azureFile": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource" + } + ], + "description": "azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver." + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity", + "type": "object" + }, + "cephfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource" + } + ], + "description": "cephFS represents a Ceph FS mount on the host that shares a pod's lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported." + }, + "cinder": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource" + } + ], + "description": "cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: https://examples.k8s.io/mysql-cinder-pd/README.md" + }, + "claimRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "claimRef is part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim. Expected to be non-nil when bound. claim.VolumeName is the authoritative bind between PV and PVC. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding", + "x-kubernetes-map-type": "granular" + }, + "csi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource" + } + ], + "description": "csi represents storage that is handled by an external CSI driver." + }, + "fc": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + } + ], + "description": "fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod." + }, + "flexVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource" + } + ], + "description": "flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead." + }, + "flocker": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + } + ], + "description": "flocker represents a Flocker volume attached to a kubelet's host machine and exposed to the pod for its usage. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported." + }, + "gcePersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + } + ], + "description": "gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk" + }, + "glusterfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource" + } + ], + "description": "glusterfs represents a Glusterfs volume that is attached to a host and exposed to the pod. Provisioned by an admin. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported. More info: https://examples.k8s.io/volumes/glusterfs/README.md" + }, + "hostPath": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + } + ], + "description": "hostPath represents a directory on the host. Provisioned by a developer or tester. This is useful for single-node development and testing only! On-host storage is not supported in any way and WILL NOT WORK in a multi-node cluster. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath" + }, + "iscsi": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource" + } + ], + "description": "iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin." + }, + "local": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource" + } + ], + "description": "local represents directly-attached storage with node affinity" + }, + "mountOptions": { + "description": "mountOptions is the list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "nfs": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + } + ], + "description": "nfs represents an NFS mount on the host. Provisioned by an admin. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs" + }, + "nodeAffinity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity" + } + ], + "description": "nodeAffinity defines constraints that limit what nodes this volume can be accessed from. This field influences the scheduling of pods that use this volume. This field is mutable if MutablePVNodeAffinity feature gate is enabled." + }, + "persistentVolumeReclaimPolicy": { + "description": "persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming", + "type": "string" + }, + "photonPersistentDisk": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + } + ], + "description": "photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported." + }, + "portworxVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + } + ], + "description": "portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver when the CSIMigrationPortworx feature-gate is on." + }, + "quobyte": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + } + ], + "description": "quobyte represents a Quobyte mount on the host that shares a pod's lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported." + }, + "rbd": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource" + } + ], + "description": "rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported. More info: https://examples.k8s.io/volumes/rbd/README.md" + }, + "scaleIO": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource" + } + ], + "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported." + }, + "storageClassName": { + "description": "storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.", + "type": "string" + }, + "storageos": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource" + } + ], + "description": "storageOS represents a StorageOS volume that is attached to the kubelet's host machine and mounted into the pod. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported. More info: https://examples.k8s.io/volumes/storageos/README.md" + }, + "volumeAttributesClassName": { + "description": "Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.", + "type": "string" + }, + "vsphereVolume": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + ], + "description": "vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDPersistentVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOPersistentVolumeSource": { + "description": "ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\"", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + ], + "description": "secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail." + }, + "sslEnabled": { + "description": "sslEnabled is the flag to enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SecretReference": { + "description": "SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace", + "properties": { + "name": { + "description": "name is unique within a namespace to reference a secret resource.", + "type": "string" + }, + "namespace": { + "description": "namespace defines the space within which the secret name must be unique.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.StorageOSPersistentVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + } + ], + "description": "secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted." + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySelectorLabelRequirement": { + "description": "A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "values": { + "description": "An array of string values. One value must match the label to be selected. Each entry in Values is ORed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "values" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TopologySelectorTerm": { + "description": "A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future.", + "properties": { + "matchLabelExpressions": { + "description": "A list of topology selector requirements by labels.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.VolumeNodeAffinity": { + "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.", + "properties": { + "required": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + ], + "description": "required specifies hard node constraints that must be met." + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSIDriver": { + "description": "CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object metadata. metadata.Name indicates the name of the CSI driver that this object refers to; it MUST be the same name returned by the CSI GetPluginName() call for that driver. The driver name must be 63 characters or less, beginning and ending with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), dots (.), and alphanumerics between. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec" + } + ], + "default": {}, + "description": "spec represents the specification of the CSI Driver." + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIDriverList": { + "description": "CSIDriverList is a collection of CSIDriver objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSIDriver", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIDriverList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIDriverSpec": { + "description": "CSIDriverSpec is the specification of a CSIDriver.", + "properties": { + "attachRequired": { + "description": "attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called.\n\nThis field is immutable.", + "type": "boolean" + }, + "fsGroupPolicy": { + "description": "fsGroupPolicy defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details.\n\nThis field was immutable in Kubernetes < 1.29 and now is mutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", + "type": "string" + }, + "nodeAllocatableUpdatePeriodSeconds": { + "description": "nodeAllocatableUpdatePeriodSeconds specifies the interval between periodic updates of the CSINode allocatable capacity for this driver. When set, both periodic updates and updates triggered by capacity-related failures are enabled. If not set, no updates occur (neither periodic nor upon detecting capacity-related failures), and the allocatable.count remains static. The minimum allowed value for this field is 10 seconds.\n\nThis is a beta feature and requires the MutableCSINodeAllocatableCount feature gate to be enabled.\n\nThis field is mutable.", + "format": "int64", + "type": "integer" + }, + "podInfoOnMount": { + "description": "podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations, if set to true. If set to false, pod information will not be passed on mount. Default is false.\n\nThe CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext.\n\nThe following VolumeContext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \"csi.storage.k8s.io/pod.name\": pod.Name \"csi.storage.k8s.io/pod.namespace\": pod.Namespace \"csi.storage.k8s.io/pod.uid\": string(pod.UID) \"csi.storage.k8s.io/ephemeral\": \"true\" if the volume is an ephemeral inline volume\n defined by a CSIVolumeSource, otherwise \"false\"\n\n\"csi.storage.k8s.io/ephemeral\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \"Persistent\" and \"Ephemeral\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver.\n\nThis field was immutable in Kubernetes < 1.29 and now is mutable.", + "type": "boolean" + }, + "requiresRepublish": { + "description": "requiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false.\n\nNote: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container.", + "type": "boolean" + }, + "seLinuxMount": { + "description": "seLinuxMount specifies if the CSI driver supports \"-o context\" mount option.\n\nWhen \"true\", the CSI driver must ensure that all volumes provided by this CSI driver can be mounted separately with different `-o context` options. This is typical for storage backends that provide volumes as filesystems on block devices or as independent shared volumes. Kubernetes will call NodeStage / NodePublish with \"-o context=xyz\" mount option when mounting a ReadWriteOncePod volume used in Pod that has explicitly set SELinux context. In the future, it may be expanded to other volume AccessModes. In any case, Kubernetes will ensure that the volume is mounted only with a single SELinux context.\n\nWhen \"false\", Kubernetes won't pass any special SELinux mount options to the driver. This is typical for volumes that represent subdirectories of a bigger shared filesystem.\n\nDefault is \"false\".", + "type": "boolean" + }, + "serviceAccountTokenInSecrets": { + "description": "serviceAccountTokenInSecrets is an opt-in for CSI drivers to indicate that service account tokens should be passed via the Secrets field in NodePublishVolumeRequest instead of the VolumeContext field. The CSI specification provides a dedicated Secrets field for sensitive information like tokens, which is the appropriate mechanism for handling credentials. This addresses security concerns where sensitive tokens were being logged as part of volume context.\n\nWhen \"true\", kubelet will pass the tokens only in the Secrets field with the key \"csi.storage.k8s.io/serviceAccount.tokens\". The CSI driver must be updated to read tokens from the Secrets field instead of VolumeContext.\n\nWhen \"false\" or not set, kubelet will pass the tokens in VolumeContext with the key \"csi.storage.k8s.io/serviceAccount.tokens\" (existing behavior). This maintains backward compatibility with existing CSI drivers.\n\nThis field can only be set when TokenRequests is configured. The API server will reject CSIDriver specs that set this field without TokenRequests.\n\nDefault behavior if unset is to pass tokens in the VolumeContext field.", + "type": "boolean" + }, + "storageCapacity": { + "description": "storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information, if set to true.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field was immutable in Kubernetes <= 1.22 and now is mutable.", + "type": "boolean" + }, + "tokenRequests": { + "description": "tokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: \"csi.storage.k8s.io/serviceAccount.tokens\": {\n \"\": {\n \"token\": ,\n \"expirationTimestamp\": ,\n },\n ...\n}\n\nNote: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.TokenRequest" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "volumeLifecycleModes": { + "description": "volumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \"Persistent\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism.\n\nThe other mode is \"Ephemeral\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume.\n\nFor more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future.\n\nThis field is beta. This field is immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.CSINode": { + "description": "CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. metadata.name must be the Kubernetes node name." + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeSpec" + } + ], + "default": {}, + "description": "spec is the specification of CSINode" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSINodeDriver": { + "description": "CSINodeDriver holds information about the specification of one CSI driver installed on a node", + "properties": { + "allocatable": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources" + } + ], + "description": "allocatable represents the volume resources of a node that are available for scheduling. This field is beta." + }, + "name": { + "default": "", + "description": "name represents the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver.", + "type": "string" + }, + "nodeID": { + "default": "", + "description": "nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as \"node1\", but the storage system may refer to the same node as \"nodeA\". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. \"nodeA\" instead of \"node1\". This field is required.", + "type": "string" + }, + "topologyKeys": { + "description": "topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. \"company.com/zone\", \"company.com/region\"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "name", + "nodeID" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSINodeList": { + "description": "CSINodeList is a collection of CSINode objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSINode", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSINodeList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSINodeSpec": { + "description": "CSINodeSpec holds information about the specification of all CSI drivers installed on a node", + "properties": { + "drivers": { + "description": "drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeDriver" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + } + }, + "required": [ + "drivers" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSIStorageCapacity": { + "description": "CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes.\n\nFor example this can express things like: - StorageClass \"standard\" has \"1234 GiB\" available in \"topology.kubernetes.io/zone=us-east1\" - StorageClass \"localssd\" has \"10 GiB\" available in \"kubernetes.io/hostname=knode-abc123\"\n\nThe following three cases all imply that no capacity is available for a certain combination: - no object exists with suitable topology and storage class name - such an object exists, but the capacity is unset - such an object exists, but the capacity is zero\n\nThe producer of these objects can decide which approach is more suitable.\n\nThey are consumed by the kube-scheduler when a CSI driver opts into capacity-aware scheduling with CSIDriverSpec.StorageCapacity. The scheduler compares the MaximumVolumeSize against the requested size of pending volumes to filter out unsuitable nodes. If MaximumVolumeSize is unset, it falls back to a comparison against the less precise Capacity. If that is also unset, the scheduler assumes that capacity is insufficient and tries some other node.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "capacity": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "capacity is the value reported by the CSI driver in its GetCapacityResponse for a GetCapacityRequest with topology and parameters that match the previous fields.\n\nThe semantic is currently (CSI spec 1.2) defined as: The available capacity, in bytes, of the storage that can be used to provision volumes. If not set, that information is currently unavailable." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "maximumVolumeSize": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + ], + "description": "maximumVolumeSize is the value reported by the CSI driver in its GetCapacityResponse for a GetCapacityRequest with topology and parameters that match the previous fields.\n\nThis is defined since CSI spec 1.4.0 as the largest size that may be used in a CreateVolumeRequest.capacity_range.required_bytes field to create a volume with the same parameters as those in GetCapacityRequest. The corresponding value in the Kubernetes API is ResourceRequirements.Requests in a volume claim." + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. The name has no particular meaning. It must be a DNS subdomain (dots allowed, 253 characters). To ensure that there are no conflicts with other CSI drivers on the cluster, the recommendation is to use csisc-, a generated name, or a reverse-domain name which ends with the unique CSI driver name.\n\nObjects are namespaced.\n\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "nodeTopology": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + } + ], + "description": "nodeTopology defines which nodes have access to the storage for which capacity was reported. If not set, the storage is not accessible from any node in the cluster. If empty, the storage is accessible from all nodes. This field is immutable." + }, + "storageClassName": { + "default": "", + "description": "storageClassName represents the name of the StorageClass that the reported capacity applies to. It must meet the same requirements as the name of a StorageClass object (non-empty, DNS subdomain). If that object no longer exists, the CSIStorageCapacity object is obsolete and should be removed by its creator. This field is immutable.", + "type": "string" + } + }, + "required": [ + "storageClassName" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIStorageCapacityList": { + "description": "CSIStorageCapacityList is a collection of CSIStorageCapacity objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSIStorageCapacity objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacityList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.StorageClass": { + "description": "StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned.\n\nStorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name.", + "properties": { + "allowVolumeExpansion": { + "description": "allowVolumeExpansion shows whether the storage class allow volume expand.", + "type": "boolean" + }, + "allowedTopologies": { + "description": "allowedTopologies restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "mountOptions": { + "description": "mountOptions controls the mountOptions for dynamically provisioned PersistentVolumes of this storage class. e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "parameters": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "parameters holds the parameters for the provisioner that should create volumes of this storage class.", + "type": "object" + }, + "provisioner": { + "default": "", + "description": "provisioner indicates the type of the provisioner.", + "type": "string" + }, + "reclaimPolicy": { + "description": "reclaimPolicy controls the reclaimPolicy for dynamically provisioned PersistentVolumes of this storage class. Defaults to Delete.", + "type": "string" + }, + "volumeBindingMode": { + "description": "volumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature.", + "type": "string" + } + }, + "required": [ + "provisioner" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.StorageClassList": { + "description": "StorageClassList is a collection of storage classes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of StorageClasses", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "StorageClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.TokenRequest": { + "description": "TokenRequest contains parameters of a service account token.", + "properties": { + "audience": { + "default": "", + "description": "audience is the intended audience of the token in \"TokenRequestSpec\". It will default to the audiences of kube apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the duration of validity of the token in \"TokenRequestSpec\". It has the same default value of \"ExpirationSeconds\" in \"TokenRequestSpec\".", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "audience" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachment": { + "description": "VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node.\n\nVolumeAttachment objects are non-namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "spec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec" + } + ], + "default": {}, + "description": "spec represents specification of the desired attach/detach volume behavior. Populated by the Kubernetes system." + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus" + } + ], + "default": {}, + "description": "status represents status of the VolumeAttachment request. Populated by the entity completing the attach or detach operation, i.e. the external-attacher." + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttachmentList": { + "description": "VolumeAttachmentList is a collection of VolumeAttachment objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of VolumeAttachments", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttachmentList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttachmentSource": { + "description": "VolumeAttachmentSource represents a volume that should be attached. Right now only PersistentVolumes can be attached via external attacher, in the future we may allow also inline volumes in pods. Exactly one member can be set.", + "properties": { + "inlineVolumeSpec": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec" + } + ], + "description": "inlineVolumeSpec contains all the information necessary to attach a persistent volume defined by a pod's inline VolumeSource. This field is populated only for the CSIMigration feature. It contains translated fields from a pod's inline VolumeSource to a PersistentVolumeSpec. This field is beta-level and is only honored by servers that enabled the CSIMigration feature." + }, + "persistentVolumeName": { + "description": "persistentVolumeName represents the name of the persistent volume to attach.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachmentSpec": { + "description": "VolumeAttachmentSpec is the specification of a VolumeAttachment request.", + "properties": { + "attacher": { + "default": "", + "description": "attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName().", + "type": "string" + }, + "nodeName": { + "default": "", + "description": "nodeName represents the node that the volume should be attached to.", + "type": "string" + }, + "source": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource" + } + ], + "default": {}, + "description": "source represents the volume that should be attached." + } + }, + "required": [ + "attacher", + "source", + "nodeName" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachmentStatus": { + "description": "VolumeAttachmentStatus is the status of a VolumeAttachment request.", + "properties": { + "attachError": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeError" + } + ], + "description": "attachError represents the last error encountered during attach operation, if any. This field must only be set by the entity completing the attach operation, i.e. the external-attacher." + }, + "attached": { + "default": false, + "description": "attached indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.", + "type": "boolean" + }, + "attachmentMetadata": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "attachmentMetadata is populated with any information returned by the attach operation, upon successful attach, that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.", + "type": "object" + }, + "detachError": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeError" + } + ], + "description": "detachError represents the last error encountered during detach operation, if any. This field must only be set by the entity completing the detach operation, i.e. the external-attacher." + } + }, + "required": [ + "attached" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttributesClass": { + "description": "VolumeAttributesClass represents a specification of mutable volume attributes defined by the CSI driver. The class can be specified during dynamic provisioning of PersistentVolumeClaims, and changed in the PersistentVolumeClaim spec after provisioning.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "driverName": { + "default": "", + "description": "Name of the CSI driver This field is immutable.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + } + ], + "default": {}, + "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "parameters": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "parameters hold volume attributes defined by the CSI driver. These values are opaque to the Kubernetes and are passed directly to the CSI driver. The underlying storage provider supports changing these attributes on an existing volume, however the parameters field itself is immutable. To invoke a volume update, a new VolumeAttributesClass should be created with new parameters, and the PersistentVolumeClaim should be updated to reference the new VolumeAttributesClass.\n\nThis field is required and must contain at least one key/value pair. The keys cannot be empty, and the maximum number of parameters is 512, with a cumulative max size of 256K. If the CSI driver rejects invalid parameters, the target PersistentVolumeClaim will be set to an \"Infeasible\" state in the modifyVolumeStatus field.", + "type": "object" + } + }, + "required": [ + "driverName" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttributesClassList": { + "description": "VolumeAttributesClassList is a collection of VolumeAttributesClass objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of VolumeAttributesClass objects.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + ], + "default": {} + }, + "type": "array" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeError": { + "description": "VolumeError captures an error encountered during a volume operation.", + "properties": { + "errorCode": { + "description": "errorCode is a numeric gRPC code representing the error encountered during Attach or Detach operations.\n\nThis is an optional, beta field that requires the MutableCSINodeAllocatableCount feature gate being enabled to be set.", + "format": "int32", + "type": "integer" + }, + "message": { + "description": "message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "time represents the time the error was encountered." + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeNodeResources": { + "description": "VolumeNodeResources is a set of resource limits for scheduling of volumes.", + "properties": { + "count": { + "description": "count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array" + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + } + ], + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + } + ], + "description": "FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type." + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over." + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + ], + "description": "DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge" + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge" + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + } + ], + "description": "Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type." + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + ], + "default": {}, + "description": "Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + } + ], + "description": "Object is:\n * If Type is Added or Modified: the new state of the object.\n * If Type is Deleted: the state of the object immediately before deletion.\n * If Type is Error: *Status is recommended; other types may make sense\n depending on context." + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/storage.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getStorageV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ] + } + }, + "/apis/storage.k8s.io/v1/csidrivers": { + "delete": { + "description": "delete collection of CSIDriver", + "operationId": "deleteStorageV1CollectionCSIDriver", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSIDriver", + "operationId": "listStorageV1CSIDriver", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSIDriver", + "operationId": "createStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csidrivers/{name}": { + "delete": { + "description": "delete a CSIDriver", + "operationId": "deleteStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSIDriver", + "operationId": "readStorageV1CSIDriver", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CSIDriver", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSIDriver", + "operationId": "patchStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSIDriver", + "operationId": "replaceStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csinodes": { + "delete": { + "description": "delete collection of CSINode", + "operationId": "deleteStorageV1CollectionCSINode", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSINode", + "operationId": "listStorageV1CSINode", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSINode", + "operationId": "createStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csinodes/{name}": { + "delete": { + "description": "delete a CSINode", + "operationId": "deleteStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSINode", + "operationId": "readStorageV1CSINode", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CSINode", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSINode", + "operationId": "patchStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSINode", + "operationId": "replaceStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csistoragecapacities": { + "get": { + "description": "list or watch objects of kind CSIStorageCapacity", + "operationId": "listStorageV1CSIStorageCapacityForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities": { + "delete": { + "description": "delete collection of CSIStorageCapacity", + "operationId": "deleteStorageV1CollectionNamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSIStorageCapacity", + "operationId": "listStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSIStorageCapacity", + "operationId": "createStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}": { + "delete": { + "description": "delete a CSIStorageCapacity", + "operationId": "deleteStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSIStorageCapacity", + "operationId": "readStorageV1NamespacedCSIStorageCapacity", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the CSIStorageCapacity", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSIStorageCapacity", + "operationId": "patchStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSIStorageCapacity", + "operationId": "replaceStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/storageclasses": { + "delete": { + "description": "delete collection of StorageClass", + "operationId": "deleteStorageV1CollectionStorageClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind StorageClass", + "operationId": "listStorageV1StorageClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a StorageClass", + "operationId": "createStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/storageclasses/{name}": { + "delete": { + "description": "delete a StorageClass", + "operationId": "deleteStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified StorageClass", + "operationId": "readStorageV1StorageClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the StorageClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified StorageClass", + "operationId": "patchStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified StorageClass", + "operationId": "replaceStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments": { + "delete": { + "description": "delete collection of VolumeAttachment", + "operationId": "deleteStorageV1CollectionVolumeAttachment", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind VolumeAttachment", + "operationId": "listStorageV1VolumeAttachment", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a VolumeAttachment", + "operationId": "createStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments/{name}": { + "delete": { + "description": "delete a VolumeAttachment", + "operationId": "deleteStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "get": { + "description": "read the specified VolumeAttachment", + "operationId": "readStorageV1VolumeAttachment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified VolumeAttachment", + "operationId": "patchStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "put": { + "description": "replace the specified VolumeAttachment", + "operationId": "replaceStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments/{name}/status": { + "get": { + "description": "read status of the specified VolumeAttachment", + "operationId": "readStorageV1VolumeAttachmentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified VolumeAttachment", + "operationId": "patchStorageV1VolumeAttachmentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified VolumeAttachment", + "operationId": "replaceStorageV1VolumeAttachmentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattributesclasses": { + "delete": { + "description": "delete collection of VolumeAttributesClass", + "operationId": "deleteStorageV1CollectionVolumeAttributesClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind VolumeAttributesClass", + "operationId": "listStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a VolumeAttributesClass", + "operationId": "createStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}": { + "delete": { + "description": "delete a VolumeAttributesClass", + "operationId": "deleteStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified VolumeAttributesClass", + "operationId": "readStorageV1VolumeAttributesClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the VolumeAttributesClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified VolumeAttributesClass", + "operationId": "patchStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified VolumeAttributesClass", + "operationId": "replaceStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "*/*": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/watch/csidrivers": { + "get": { + "description": "watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSIDriverList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csidrivers/{name}": { + "get": { + "description": "watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1CSIDriver", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSIDriver", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csinodes": { + "get": { + "description": "watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSINodeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csinodes/{name}": { + "get": { + "description": "watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1CSINode", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSINode", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csistoragecapacities": { + "get": { + "description": "watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSIStorageCapacityListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities": { + "get": { + "description": "watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1NamespacedCSIStorageCapacityList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}": { + "get": { + "description": "watch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1NamespacedCSIStorageCapacity", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSIStorageCapacity", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/storageclasses": { + "get": { + "description": "watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1StorageClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/storageclasses/{name}": { + "get": { + "description": "watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1StorageClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the StorageClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattachments": { + "get": { + "description": "watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1VolumeAttachmentList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattachments/{name}": { + "get": { + "description": "watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1VolumeAttachment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattributesclasses": { + "get": { + "description": "watch individual changes to a list of VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1VolumeAttributesClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattributesclasses/{name}": { + "get": { + "description": "watch changes to an object of kind VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1VolumeAttributesClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the VolumeAttributesClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1/specs/apis_storage.k8s.io_v1_patched.json b/gen/openapi_v1/specs/apis_storage.k8s.io_v1_patched.json new file mode 100644 index 00000000..315beca7 --- /dev/null +++ b/gen/openapi_v1/specs/apis_storage.k8s.io_v1_patched.json @@ -0,0 +1,10981 @@ +{ + "components": { + "schemas": { + "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": { + "description": "Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureDiskVolumeSource": { + "description": "AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.", + "properties": { + "cachingMode": { + "default": "ReadWrite", + "description": "cachingMode is the Host Caching mode: None, Read Only, Read Write.", + "type": "string" + }, + "diskName": { + "default": "", + "description": "diskName is the Name of the data disk in the blob storage", + "type": "string" + }, + "diskURI": { + "default": "", + "description": "diskURI is the URI of data disk in the blob storage", + "type": "string" + }, + "fsType": { + "default": "ext4", + "description": "fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "kind": { + "default": "Shared", + "description": "kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared", + "type": "string" + }, + "readOnly": { + "default": false, + "description": "readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + } + }, + "required": [ + "diskName", + "diskURI" + ], + "type": "object" + }, + "io.k8s.api.core.v1.AzureFilePersistentVolumeSource": { + "description": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.", + "properties": { + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretName": { + "default": "", + "description": "secretName is the name of secret that contains Azure Storage Account Name and Key", + "type": "string" + }, + "secretNamespace": { + "description": "secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod", + "type": "string" + }, + "shareName": { + "default": "", + "description": "shareName is the azure Share Name", + "type": "string" + } + }, + "required": [ + "secretName", + "shareName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CSIPersistentVolumeSource": { + "description": "Represents storage that is managed by an external CSI volume driver", + "properties": { + "controllerExpandSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "controllerPublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume. Required.", + "type": "string" + }, + "fsType": { + "description": "fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\".", + "type": "string" + }, + "nodeExpandSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "nodePublishSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "nodeStageSecretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "readOnly": { + "description": "readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).", + "type": "boolean" + }, + "volumeAttributes": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "volumeAttributes of the volume to publish.", + "type": "object" + }, + "volumeHandle": { + "default": "", + "description": "volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.", + "type": "string" + } + }, + "required": [ + "driver", + "volumeHandle" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CephFSPersistentVolumeSource": { + "description": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "monitors": { + "description": "monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "path": { + "description": "path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "boolean" + }, + "secretFile": { + "description": "secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "user": { + "description": "user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors" + ], + "type": "object" + }, + "io.k8s.api.core.v1.CinderPersistentVolumeSource": { + "description": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "volumeID": { + "default": "", + "description": "volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FCVolumeSource": { + "description": "Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "lun": { + "description": "lun is Optional: FC target lun number", + "format": "int32", + "type": "integer" + }, + "readOnly": { + "description": "readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "targetWWNs": { + "description": "targetWWNs is Optional: FC target worldwide names (WWNs)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "wwids": { + "description": "wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.FlexPersistentVolumeSource": { + "description": "FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.", + "properties": { + "driver": { + "default": "", + "description": "driver is the name of the driver to use for this volume.", + "type": "string" + }, + "fsType": { + "description": "fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.", + "type": "string" + }, + "options": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "options is Optional: this field holds extra command options if any.", + "type": "object" + }, + "readOnly": { + "description": "readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + } + }, + "required": [ + "driver" + ], + "type": "object" + }, + "io.k8s.api.core.v1.FlockerVolumeSource": { + "description": "Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.", + "properties": { + "datasetName": { + "description": "datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated", + "type": "string" + }, + "datasetUUID": { + "description": "datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": { + "description": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "partition": { + "description": "partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "format": "int32", + "type": "integer" + }, + "pdName": { + "default": "", + "description": "pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk", + "type": "boolean" + } + }, + "required": [ + "pdName" + ], + "type": "object" + }, + "io.k8s.api.core.v1.GlusterfsPersistentVolumeSource": { + "description": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.", + "properties": { + "endpoints": { + "default": "", + "description": "endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "endpointsNamespace": { + "description": "endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "path": { + "default": "", + "description": "path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod", + "type": "boolean" + } + }, + "required": [ + "endpoints", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.HostPathVolumeSource": { + "description": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + }, + "type": { + "description": "type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ISCSIPersistentVolumeSource": { + "description": "ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.", + "properties": { + "chapAuthDiscovery": { + "description": "chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication", + "type": "boolean" + }, + "chapAuthSession": { + "description": "chapAuthSession defines whether support iSCSI Session CHAP authentication", + "type": "boolean" + }, + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi", + "type": "string" + }, + "initiatorName": { + "description": "initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.", + "type": "string" + }, + "iqn": { + "default": "", + "description": "iqn is Target iSCSI Qualified Name.", + "type": "string" + }, + "iscsiInterface": { + "default": "default", + "description": "iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).", + "type": "string" + }, + "lun": { + "default": 0, + "description": "lun is iSCSI Target Lun number.", + "format": "int32", + "type": "integer" + }, + "portals": { + "description": "portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "targetPortal": { + "default": "", + "description": "targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).", + "type": "string" + } + }, + "required": [ + "targetPortal", + "iqn", + "lun" + ], + "type": "object" + }, + "io.k8s.api.core.v1.LocalVolumeSource": { + "description": "Local represents directly-attached storage with node affinity", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a filesystem if unspecified.", + "type": "string" + }, + "path": { + "default": "", + "description": "path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).", + "type": "string" + } + }, + "required": [ + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NFSVolumeSource": { + "description": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.", + "properties": { + "path": { + "default": "", + "description": "path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "boolean" + }, + "server": { + "default": "", + "description": "server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs", + "type": "string" + } + }, + "required": [ + "server", + "path" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelector": { + "description": "A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.", + "properties": { + "nodeSelectorTerms": { + "description": "Required. A list of node selector terms. The terms are ORed.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "nodeSelectorTerms" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.NodeSelectorRequirement": { + "description": "A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.", + "type": "string" + }, + "values": { + "description": "An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.api.core.v1.NodeSelectorTerm": { + "description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.", + "properties": { + "matchExpressions": { + "description": "A list of node selector requirements by node's labels.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchFields": { + "description": "A list of node selector requirements by node's fields.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.ObjectReference": { + "description": "ObjectReference contains enough information to let you inspect or modify the referred object.", + "properties": { + "apiVersion": { + "description": "API version of the referent.", + "type": "string" + }, + "fieldPath": { + "description": "If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.", + "type": "string" + }, + "kind": { + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", + "type": "string" + }, + "namespace": { + "description": "Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/", + "type": "string" + }, + "resourceVersion": { + "description": "Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "uid": { + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.PersistentVolumeSpec": { + "description": "PersistentVolumeSpec is the specification of a persistent volume.", + "properties": { + "accessModes": { + "description": "accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "awsElasticBlockStore": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource" + }, + "azureDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource" + }, + "azureFile": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource" + }, + "capacity": { + "additionalProperties": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity", + "type": "object" + }, + "cephfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource" + }, + "cinder": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource" + }, + "claimRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "csi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource" + }, + "fc": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FCVolumeSource" + }, + "flexVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource" + }, + "flocker": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource" + }, + "gcePersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource" + }, + "glusterfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource" + }, + "hostPath": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource" + }, + "iscsi": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource" + }, + "local": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource" + }, + "mountOptions": { + "description": "mountOptions is the list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "nfs": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource" + }, + "nodeAffinity": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity" + }, + "persistentVolumeReclaimPolicy": { + "description": "persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming", + "type": "string" + }, + "photonPersistentDisk": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource" + }, + "portworxVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource" + }, + "quobyte": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource" + }, + "rbd": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource" + }, + "scaleIO": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource" + }, + "storageClassName": { + "description": "storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.", + "type": "string" + }, + "storageos": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource" + }, + "volumeAttributesClassName": { + "description": "Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.", + "type": "string" + }, + "volumeMode": { + "description": "volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.", + "type": "string" + }, + "vsphereVolume": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": { + "description": "Represents a Photon Controller persistent disk resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "pdID": { + "default": "", + "description": "pdID is the ID that identifies Photon Controller persistent disk", + "type": "string" + } + }, + "required": [ + "pdID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.PortworxVolumeSource": { + "description": "PortworxVolumeSource represents a Portworx volume resource.", + "properties": { + "fsType": { + "description": "fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "volumeID": { + "default": "", + "description": "volumeID uniquely identifies a Portworx volume", + "type": "string" + } + }, + "required": [ + "volumeID" + ], + "type": "object" + }, + "io.k8s.api.core.v1.QuobyteVolumeSource": { + "description": "Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.", + "properties": { + "group": { + "description": "group to map volume access to Default is no group", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.", + "type": "boolean" + }, + "registry": { + "default": "", + "description": "registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes", + "type": "string" + }, + "tenant": { + "description": "tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin", + "type": "string" + }, + "user": { + "description": "user to map volume access to Defaults to serivceaccount user", + "type": "string" + }, + "volume": { + "default": "", + "description": "volume is a string that references an already created Quobyte volume by name.", + "type": "string" + } + }, + "required": [ + "registry", + "volume" + ], + "type": "object" + }, + "io.k8s.api.core.v1.RBDPersistentVolumeSource": { + "description": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd", + "type": "string" + }, + "image": { + "default": "", + "description": "image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "keyring": { + "default": "/etc/ceph/keyring", + "description": "keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "monitors": { + "description": "monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "pool": { + "default": "rbd", + "description": "pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + }, + "readOnly": { + "description": "readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "user": { + "default": "admin", + "description": "user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it", + "type": "string" + } + }, + "required": [ + "monitors", + "image" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ScaleIOPersistentVolumeSource": { + "description": "ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume", + "properties": { + "fsType": { + "default": "xfs", + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\"", + "type": "string" + }, + "gateway": { + "default": "", + "description": "gateway is the host address of the ScaleIO API Gateway.", + "type": "string" + }, + "protectionDomain": { + "description": "protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.SecretReference" + }, + "sslEnabled": { + "description": "sslEnabled is the flag to enable/disable SSL communication with Gateway, default false", + "type": "boolean" + }, + "storageMode": { + "default": "ThinProvisioned", + "description": "storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.", + "type": "string" + }, + "storagePool": { + "description": "storagePool is the ScaleIO Storage Pool associated with the protection domain.", + "type": "string" + }, + "system": { + "default": "", + "description": "system is the name of the storage system as configured in ScaleIO.", + "type": "string" + }, + "volumeName": { + "description": "volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.", + "type": "string" + } + }, + "required": [ + "gateway", + "system", + "secretRef" + ], + "type": "object" + }, + "io.k8s.api.core.v1.SecretReference": { + "description": "SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace", + "properties": { + "name": { + "description": "name is unique within a namespace to reference a secret resource.", + "type": "string" + }, + "namespace": { + "description": "namespace defines the space within which the secret name must be unique.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.StorageOSPersistentVolumeSource": { + "description": "Represents a StorageOS persistent volume resource.", + "properties": { + "fsType": { + "description": "fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "readOnly": { + "description": "readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.", + "type": "boolean" + }, + "secretRef": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ObjectReference" + }, + "volumeName": { + "description": "volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.", + "type": "string" + }, + "volumeNamespace": { + "description": "volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.TopologySelectorLabelRequirement": { + "description": "A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future.", + "properties": { + "key": { + "default": "", + "description": "The label key that the selector applies to.", + "type": "string" + }, + "values": { + "description": "An array of string values. One value must match the label to be selected. Each entry in Values is ORed.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "values" + ], + "type": "object" + }, + "io.k8s.api.core.v1.TopologySelectorTerm": { + "description": "A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future.", + "properties": { + "matchLabelExpressions": { + "description": "A list of topology selector requirements by labels.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.api.core.v1.VolumeNodeAffinity": { + "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.", + "properties": { + "required": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.NodeSelector" + } + }, + "type": "object" + }, + "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": { + "description": "Represents a vSphere volume resource.", + "properties": { + "fsType": { + "description": "fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.", + "type": "string" + }, + "storagePolicyID": { + "description": "storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.", + "type": "string" + }, + "storagePolicyName": { + "description": "storagePolicyName is the storage Policy Based Management (SPBM) profile name.", + "type": "string" + }, + "volumePath": { + "default": "", + "description": "volumePath is the path that identifies vSphere volume vmdk", + "type": "string" + } + }, + "required": [ + "volumePath" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSIDriver": { + "description": "CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIDriverList": { + "description": "CSIDriverList is a collection of CSIDriver objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSIDriver", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIDriverList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIDriverSpec": { + "description": "CSIDriverSpec is the specification of a CSIDriver.", + "properties": { + "attachRequired": { + "description": "attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called.\n\nThis field is immutable.", + "type": "boolean" + }, + "fsGroupPolicy": { + "description": "fsGroupPolicy defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details.\n\nThis field was immutable in Kubernetes < 1.29 and now is mutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", + "type": "string" + }, + "nodeAllocatableUpdatePeriodSeconds": { + "description": "nodeAllocatableUpdatePeriodSeconds specifies the interval between periodic updates of the CSINode allocatable capacity for this driver. When set, both periodic updates and updates triggered by capacity-related failures are enabled. If not set, no updates occur (neither periodic nor upon detecting capacity-related failures), and the allocatable.count remains static. The minimum allowed value for this field is 10 seconds.\n\nThis is a beta feature and requires the MutableCSINodeAllocatableCount feature gate to be enabled.\n\nThis field is mutable.", + "format": "int64", + "type": "integer" + }, + "podInfoOnMount": { + "description": "podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations, if set to true. If set to false, pod information will not be passed on mount. Default is false.\n\nThe CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext.\n\nThe following VolumeContext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \"csi.storage.k8s.io/pod.name\": pod.Name \"csi.storage.k8s.io/pod.namespace\": pod.Namespace \"csi.storage.k8s.io/pod.uid\": string(pod.UID) \"csi.storage.k8s.io/ephemeral\": \"true\" if the volume is an ephemeral inline volume\n defined by a CSIVolumeSource, otherwise \"false\"\n\n\"csi.storage.k8s.io/ephemeral\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \"Persistent\" and \"Ephemeral\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver.\n\nThis field was immutable in Kubernetes < 1.29 and now is mutable.", + "type": "boolean" + }, + "requiresRepublish": { + "description": "requiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false.\n\nNote: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container.", + "type": "boolean" + }, + "seLinuxMount": { + "description": "seLinuxMount specifies if the CSI driver supports \"-o context\" mount option.\n\nWhen \"true\", the CSI driver must ensure that all volumes provided by this CSI driver can be mounted separately with different `-o context` options. This is typical for storage backends that provide volumes as filesystems on block devices or as independent shared volumes. Kubernetes will call NodeStage / NodePublish with \"-o context=xyz\" mount option when mounting a ReadWriteOncePod volume used in Pod that has explicitly set SELinux context. In the future, it may be expanded to other volume AccessModes. In any case, Kubernetes will ensure that the volume is mounted only with a single SELinux context.\n\nWhen \"false\", Kubernetes won't pass any special SELinux mount options to the driver. This is typical for volumes that represent subdirectories of a bigger shared filesystem.\n\nDefault is \"false\".", + "type": "boolean" + }, + "serviceAccountTokenInSecrets": { + "description": "serviceAccountTokenInSecrets is an opt-in for CSI drivers to indicate that service account tokens should be passed via the Secrets field in NodePublishVolumeRequest instead of the VolumeContext field. The CSI specification provides a dedicated Secrets field for sensitive information like tokens, which is the appropriate mechanism for handling credentials. This addresses security concerns where sensitive tokens were being logged as part of volume context.\n\nWhen \"true\", kubelet will pass the tokens only in the Secrets field with the key \"csi.storage.k8s.io/serviceAccount.tokens\". The CSI driver must be updated to read tokens from the Secrets field instead of VolumeContext.\n\nWhen \"false\" or not set, kubelet will pass the tokens in VolumeContext with the key \"csi.storage.k8s.io/serviceAccount.tokens\" (existing behavior). This maintains backward compatibility with existing CSI drivers.\n\nThis field can only be set when TokenRequests is configured. The API server will reject CSIDriver specs that set this field without TokenRequests.\n\nDefault behavior if unset is to pass tokens in the VolumeContext field.", + "type": "boolean" + }, + "storageCapacity": { + "description": "storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information, if set to true.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field was immutable in Kubernetes <= 1.22 and now is mutable.", + "type": "boolean" + }, + "tokenRequests": { + "description": "tokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: \"csi.storage.k8s.io/serviceAccount.tokens\": {\n \"\": {\n \"token\": ,\n \"expirationTimestamp\": ,\n },\n ...\n}\n\nNote: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.TokenRequest" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "volumeLifecycleModes": { + "description": "volumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \"Persistent\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism.\n\nThe other mode is \"Ephemeral\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume.\n\nFor more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future.\n\nThis field is beta. This field is immutable.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "nullable": true + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.CSINode": { + "description": "CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeSpec" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSINodeDriver": { + "description": "CSINodeDriver holds information about the specification of one CSI driver installed on a node", + "properties": { + "allocatable": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources" + }, + "name": { + "default": "", + "description": "name represents the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver.", + "type": "string" + }, + "nodeID": { + "default": "", + "description": "nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as \"node1\", but the storage system may refer to the same node as \"nodeA\". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. \"nodeA\" instead of \"node1\". This field is required.", + "type": "string" + }, + "topologyKeys": { + "description": "topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. \"company.com/zone\", \"company.com/region\"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "name", + "nodeID" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSINodeList": { + "description": "CSINodeList is a collection of CSINode objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSINode", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSINodeList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSINodeSpec": { + "description": "CSINodeSpec holds information about the specification of all CSI drivers installed on a node", + "properties": { + "drivers": { + "description": "drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeDriver" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + } + }, + "required": [ + "drivers" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.CSIStorageCapacity": { + "description": "CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes.\n\nFor example this can express things like: - StorageClass \"standard\" has \"1234 GiB\" available in \"topology.kubernetes.io/zone=us-east1\" - StorageClass \"localssd\" has \"10 GiB\" available in \"kubernetes.io/hostname=knode-abc123\"\n\nThe following three cases all imply that no capacity is available for a certain combination: - no object exists with suitable topology and storage class name - such an object exists, but the capacity is unset - such an object exists, but the capacity is zero\n\nThe producer of these objects can decide which approach is more suitable.\n\nThey are consumed by the kube-scheduler when a CSI driver opts into capacity-aware scheduling with CSIDriverSpec.StorageCapacity. The scheduler compares the MaximumVolumeSize against the requested size of pending volumes to filter out unsuitable nodes. If MaximumVolumeSize is unset, it falls back to a comparison against the less precise Capacity. If that is also unset, the scheduler assumes that capacity is insufficient and tries some other node.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "capacity": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "maximumVolumeSize": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "nodeTopology": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" + }, + "storageClassName": { + "default": "", + "description": "storageClassName represents the name of the StorageClass that the reported capacity applies to. It must meet the same requirements as the name of a StorageClass object (non-empty, DNS subdomain). If that object no longer exists, the CSIStorageCapacity object is obsolete and should be removed by its creator. This field is immutable.", + "type": "string" + } + }, + "required": [ + "storageClassName" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.CSIStorageCapacityList": { + "description": "CSIStorageCapacityList is a collection of CSIStorageCapacity objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of CSIStorageCapacity objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacityList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.StorageClass": { + "description": "StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned.\n\nStorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name.", + "properties": { + "allowVolumeExpansion": { + "description": "allowVolumeExpansion shows whether the storage class allow volume expand.", + "type": "boolean" + }, + "allowedTopologies": { + "description": "allowedTopologies restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "mountOptions": { + "description": "mountOptions controls the mountOptions for dynamically provisioned PersistentVolumes of this storage class. e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "parameters": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "parameters holds the parameters for the provisioner that should create volumes of this storage class.", + "type": "object" + }, + "provisioner": { + "default": "", + "description": "provisioner indicates the type of the provisioner.", + "type": "string" + }, + "reclaimPolicy": { + "description": "reclaimPolicy controls the reclaimPolicy for dynamically provisioned PersistentVolumes of this storage class. Defaults to Delete.", + "type": "string" + }, + "volumeBindingMode": { + "description": "volumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature.", + "type": "string" + } + }, + "required": [ + "provisioner" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.StorageClassList": { + "description": "StorageClassList is a collection of storage classes.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of StorageClasses", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "StorageClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.TokenRequest": { + "description": "TokenRequest contains parameters of a service account token.", + "properties": { + "audience": { + "default": "", + "description": "audience is the intended audience of the token in \"TokenRequestSpec\". It will default to the audiences of kube apiserver.", + "type": "string" + }, + "expirationSeconds": { + "description": "expirationSeconds is the duration of validity of the token in \"TokenRequestSpec\". It has the same default value of \"ExpirationSeconds\" in \"TokenRequestSpec\".", + "format": "int64", + "type": "integer" + } + }, + "required": [ + "audience" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachment": { + "description": "VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node.\n\nVolumeAttachment objects are non-namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec" + }, + "status": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus" + } + }, + "required": [ + "spec" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttachmentList": { + "description": "VolumeAttachmentList is a collection of VolumeAttachment objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of VolumeAttachments", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttachmentList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttachmentSource": { + "description": "VolumeAttachmentSource represents a volume that should be attached. Right now only PersistentVolumes can be attached via external attacher, in the future we may allow also inline volumes in pods. Exactly one member can be set.", + "properties": { + "inlineVolumeSpec": { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec" + }, + "persistentVolumeName": { + "description": "persistentVolumeName represents the name of the persistent volume to attach.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachmentSpec": { + "description": "VolumeAttachmentSpec is the specification of a VolumeAttachment request.", + "properties": { + "attacher": { + "default": "", + "description": "attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName().", + "type": "string" + }, + "nodeName": { + "default": "", + "description": "nodeName represents the node that the volume should be attached to.", + "type": "string" + }, + "source": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource" + } + }, + "required": [ + "attacher", + "source", + "nodeName" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttachmentStatus": { + "description": "VolumeAttachmentStatus is the status of a VolumeAttachment request.", + "properties": { + "attachError": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeError" + }, + "attached": { + "default": false, + "description": "attached indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.", + "type": "boolean" + }, + "attachmentMetadata": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "attachmentMetadata is populated with any information returned by the attach operation, upon successful attach, that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.", + "type": "object" + }, + "detachError": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeError" + } + }, + "required": [ + "attached" + ], + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeAttributesClass": { + "description": "VolumeAttributesClass represents a specification of mutable volume attributes defined by the CSI driver. The class can be specified during dynamic provisioning of PersistentVolumeClaims, and changed in the PersistentVolumeClaim spec after provisioning.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "driverName": { + "default": "", + "description": "Name of the CSI driver This field is immutable.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "parameters": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "parameters hold volume attributes defined by the CSI driver. These values are opaque to the Kubernetes and are passed directly to the CSI driver. The underlying storage provider supports changing these attributes on an existing volume, however the parameters field itself is immutable. To invoke a volume update, a new VolumeAttributesClass should be created with new parameters, and the PersistentVolumeClaim should be updated to reference the new VolumeAttributesClass.\n\nThis field is required and must contain at least one key/value pair. The keys cannot be empty, and the maximum number of parameters is 512, with a cumulative max size of 256K. If the CSI driver rejects invalid parameters, the target PersistentVolumeClaim will be set to an \"Infeasible\" state in the modifyVolumeStatus field.", + "type": "object" + } + }, + "required": [ + "driverName" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeAttributesClassList": { + "description": "VolumeAttributesClassList is a collection of VolumeAttributesClass objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "items": { + "description": "items is the list of VolumeAttributesClass objects.", + "items": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + }, + "type": "array", + "nullable": true + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + }, + "required": [ + "items" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClassList", + "version": "v1" + } + ] + }, + "io.k8s.api.storage.v1.VolumeError": { + "description": "VolumeError captures an error encountered during a volume operation.", + "properties": { + "errorCode": { + "description": "errorCode is a numeric gRPC code representing the error encountered during Attach or Detach operations.\n\nThis is an optional, beta field that requires the MutableCSINodeAllocatableCount feature gate being enabled to be set.", + "format": "int32", + "type": "integer" + }, + "message": { + "description": "message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.api.storage.v1.VolumeNodeResources": { + "description": "VolumeNodeResources is a set of resource limits for scheduling of volumes.", + "properties": { + "count": { + "description": "count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.api.resource.Quantity": { + "description": "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` ::= \n\n\t(Note that may be empty, from the \"\" case in .)\n\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \"+\" | \"-\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n ::= \"e\" | \"E\" ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "properties": { + "categories": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": "string" + }, + "kind": { + "default": "", + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": "string" + }, + "name": { + "default": "", + "description": "name is the plural name of the resource.", + "type": "string" + }, + "namespaced": { + "default": false, + "description": "namespaced indicates if a resource is namespaced or not.", + "type": "boolean" + }, + "shortNames": { + "description": "shortNames is a list of suggested short names of the resource.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "singularName": { + "default": "", + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": "string" + }, + "storageVersionHash": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": "string" + }, + "verbs": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "nullable": true + }, + "version": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": "string" + } + }, + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "groupVersion": { + "default": "", + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": "string" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "resources": { + "description": "resources contains the name of the resources and if they are namespaced.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "groupVersion", + "resources" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "APIResourceList", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { + "description": "DeleteOptions may be provided when deleting an API object.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "dryRun": { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "gracePeriodSeconds": { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "format": "int64", + "type": "integer" + }, + "ignoreStoreReadErrorWithClusterBreakingPotential": { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "type": "boolean" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "orphanDependents": { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "type": "boolean" + }, + "preconditions": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" + }, + "propagationPolicy": { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "DeleteOptions", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "batch", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "policy", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "DeleteOptions", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": { + "description": "FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": { + "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.", + "properties": { + "matchExpressions": { + "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "matchLabels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.", + "type": "object" + } + }, + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": { + "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.", + "properties": { + "key": { + "default": "", + "description": "key is the label key that the selector applies to.", + "type": "string" + }, + "operator": { + "default": "", + "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.", + "type": "string" + }, + "values": { + "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + } + }, + "required": [ + "key", + "operator" + ], + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": { + "description": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.", + "properties": { + "continue": { + "description": "continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.", + "type": "string" + }, + "remainingItemCount": { + "description": "remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.", + "format": "int64", + "type": "integer" + }, + "resourceVersion": { + "description": "String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": { + "description": "ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.", + "type": "string" + }, + "fieldsType": { + "description": "FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"", + "type": "string" + }, + "fieldsV1": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1" + }, + "manager": { + "description": "Manager is an identifier of the workflow managing these fields.", + "type": "string" + }, + "operation": { + "description": "Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.", + "type": "string" + }, + "subresource": { + "description": "Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.", + "type": "string" + }, + "time": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": { + "description": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.", + "properties": { + "annotations": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations", + "type": "object" + }, + "creationTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "deletionGracePeriodSeconds": { + "description": "Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.", + "format": "int64", + "type": "integer" + }, + "deletionTimestamp": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time" + }, + "finalizers": { + "description": "Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "set", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "generateName": { + "description": "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency", + "type": "string" + }, + "generation": { + "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.", + "format": "int64", + "type": "integer" + }, + "labels": { + "additionalProperties": { + "default": "", + "type": "string" + }, + "description": "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels", + "type": "object" + }, + "managedFields": { + "description": "ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "name": { + "description": "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "namespace": { + "description": "Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces", + "type": "string" + }, + "ownerReferences": { + "description": "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "uid" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "uid", + "x-kubernetes-patch-strategy": "merge", + "nullable": true + }, + "resourceVersion": { + "description": "An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency", + "type": "string" + }, + "selfLink": { + "description": "Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.", + "type": "string" + }, + "uid": { + "description": "UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": { + "description": "OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.", + "properties": { + "apiVersion": { + "default": "", + "description": "API version of the referent.", + "type": "string" + }, + "blockOwnerDeletion": { + "description": "If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.", + "type": "boolean" + }, + "controller": { + "description": "If true, this reference points to the managing controller.", + "type": "boolean" + }, + "kind": { + "default": "", + "description": "Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "default": "", + "description": "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names", + "type": "string" + }, + "uid": { + "default": "", + "description": "UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "required": [ + "apiVersion", + "kind", + "name", + "uid" + ], + "type": "object", + "x-kubernetes-map-type": "atomic" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Patch": { + "description": "Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { + "description": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.", + "properties": { + "resourceVersion": { + "description": "Specifies the target ResourceVersion", + "type": "string" + }, + "uid": { + "description": "Specifies the target UID.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Status": { + "description": "Status is a return value for calls that don't return other objects.", + "properties": { + "apiVersion": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": "string" + }, + "code": { + "description": "Suggested HTTP return code for this status, 0 if not set.", + "format": "int32", + "type": "integer" + }, + "details": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails" + }, + "kind": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "message": { + "description": "A human-readable description of the status of this operation.", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + }, + "reason": { + "description": "A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.", + "type": "string" + }, + "status": { + "description": "Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "type": "string" + } + }, + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "Status", + "version": "v1" + } + ] + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause": { + "description": "StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.", + "properties": { + "field": { + "description": "The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\n\nExamples:\n \"name\" - the field \"name\" on the current resource\n \"items[0].name\" - the field \"name\" on the first array entry in \"items\"", + "type": "string" + }, + "message": { + "description": "A human-readable description of the cause of the error. This field may be presented as-is to a reader.", + "type": "string" + }, + "reason": { + "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails": { + "description": "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.", + "properties": { + "causes": { + "description": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.", + "items": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause" + }, + "type": "array", + "x-kubernetes-list-type": "atomic", + "nullable": true + }, + "group": { + "description": "The group attribute of the resource associated with the status StatusReason.", + "type": "string" + }, + "kind": { + "description": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": "string" + }, + "name": { + "description": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).", + "type": "string" + }, + "retryAfterSeconds": { + "description": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.", + "format": "int32", + "type": "integer" + }, + "uid": { + "description": "UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids", + "type": "string" + } + }, + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.Time": { + "description": "Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.", + "format": "date-time", + "type": "string", + "nullable": true + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent": { + "description": "Event represents a single event to a watched resource.", + "properties": { + "object": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension" + }, + "type": { + "default": "", + "type": "string" + } + }, + "required": [ + "type", + "object" + ], + "type": "object", + "x-kubernetes-group-version-kind": [ + { + "group": "", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admission.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "admissionregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiextensions.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apiregistration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "apps", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "authentication.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta1" + }, + { + "group": "autoscaling", + "kind": "WatchEvent", + "version": "v2beta2" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "batch", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "certificates.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha2" + }, + { + "group": "coordination.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "discovery.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "events.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "extensions", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "flowcontrol.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1beta3" + }, + { + "group": "imagepolicy.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "internal.apiserver.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "networking.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "node.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "policy", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "rbac.authorization.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha3" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "resource.k8s.io", + "kind": "WatchEvent", + "version": "v1beta2" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "scheduling.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1alpha1" + }, + { + "group": "storage.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + }, + { + "group": "storagemigration.k8s.io", + "kind": "WatchEvent", + "version": "v1beta1" + } + ] + }, + "io.k8s.apimachinery.pkg.runtime.RawExtension": { + "description": "RawExtension is used to hold extensions in external versions.\n\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\n\n// Internal package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.Object `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// External package:\n\n\ttype MyAPIObject struct {\n\t\truntime.TypeMeta `json:\",inline\"`\n\t\tMyPlugin runtime.RawExtension `json:\"myPlugin\"`\n\t}\n\n\ttype PluginA struct {\n\t\tAOption string `json:\"aOption\"`\n\t}\n\n// On the wire, the JSON will look something like this:\n\n\t{\n\t\t\"kind\":\"MyAPIObject\",\n\t\t\"apiVersion\":\"v1\",\n\t\t\"myPlugin\": {\n\t\t\t\"kind\":\"PluginA\",\n\t\t\t\"aOption\":\"foo\",\n\t\t},\n\t}\n\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)", + "type": "object" + }, + "io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch": { + "description": "A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.", + "type": "array", + "items": { + "type": "object" + } + } + }, + "securitySchemes": { + "BearerToken": { + "description": "Bearer Token authentication", + "in": "header", + "name": "authorization", + "type": "apiKey" + } + } + }, + "info": { + "title": "Kubernetes", + "version": "unversioned" + }, + "openapi": "3.0.0", + "paths": { + "/apis/storage.k8s.io/v1/": { + "get": { + "description": "get available resources", + "operationId": "getStorageV1APIResources", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ] + } + }, + "/apis/storage.k8s.io/v1/csidrivers": { + "delete": { + "description": "delete collection of CSIDriver", + "operationId": "deleteStorageV1CollectionCSIDriver", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSIDriver", + "operationId": "listStorageV1CSIDriver", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriverList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSIDriver", + "operationId": "createStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csidrivers/{name}": { + "delete": { + "description": "delete a CSIDriver", + "operationId": "deleteStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSIDriver", + "operationId": "readStorageV1CSIDriver", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CSIDriver", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSIDriver", + "operationId": "patchStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSIDriver", + "operationId": "replaceStorageV1CSIDriver", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIDriver" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csinodes": { + "delete": { + "description": "delete collection of CSINode", + "operationId": "deleteStorageV1CollectionCSINode", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSINode", + "operationId": "listStorageV1CSINode", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINodeList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSINode", + "operationId": "createStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csinodes/{name}": { + "delete": { + "description": "delete a CSINode", + "operationId": "deleteStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSINode", + "operationId": "readStorageV1CSINode", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CSINode", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSINode", + "operationId": "patchStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSINode", + "operationId": "replaceStorageV1CSINode", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSINode" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/csistoragecapacities": { + "get": { + "description": "list or watch objects of kind CSIStorageCapacity", + "operationId": "listStorageV1CSIStorageCapacityForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities": { + "delete": { + "description": "delete collection of CSIStorageCapacity", + "operationId": "deleteStorageV1CollectionNamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind CSIStorageCapacity", + "operationId": "listStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a CSIStorageCapacity", + "operationId": "createStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}": { + "delete": { + "description": "delete a CSIStorageCapacity", + "operationId": "deleteStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "get": { + "description": "read the specified CSIStorageCapacity", + "operationId": "readStorageV1NamespacedCSIStorageCapacity", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the CSIStorageCapacity", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified CSIStorageCapacity", + "operationId": "patchStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "put": { + "description": "replace the specified CSIStorageCapacity", + "operationId": "replaceStorageV1NamespacedCSIStorageCapacity", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/storageclasses": { + "delete": { + "description": "delete collection of StorageClass", + "operationId": "deleteStorageV1CollectionStorageClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind StorageClass", + "operationId": "listStorageV1StorageClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a StorageClass", + "operationId": "createStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/storageclasses/{name}": { + "delete": { + "description": "delete a StorageClass", + "operationId": "deleteStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified StorageClass", + "operationId": "readStorageV1StorageClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the StorageClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified StorageClass", + "operationId": "patchStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified StorageClass", + "operationId": "replaceStorageV1StorageClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.StorageClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments": { + "delete": { + "description": "delete collection of VolumeAttachment", + "operationId": "deleteStorageV1CollectionVolumeAttachment", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind VolumeAttachment", + "operationId": "listStorageV1VolumeAttachment", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a VolumeAttachment", + "operationId": "createStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments/{name}": { + "delete": { + "description": "delete a VolumeAttachment", + "operationId": "deleteStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "get": { + "description": "read the specified VolumeAttachment", + "operationId": "readStorageV1VolumeAttachment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified VolumeAttachment", + "operationId": "patchStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "put": { + "description": "replace the specified VolumeAttachment", + "operationId": "replaceStorageV1VolumeAttachment", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattachments/{name}/status": { + "get": { + "description": "read status of the specified VolumeAttachment", + "operationId": "readStorageV1VolumeAttachmentStatus", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update status of the specified VolumeAttachment", + "operationId": "patchStorageV1VolumeAttachmentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "put": { + "description": "replace status of the specified VolumeAttachment", + "operationId": "replaceStorageV1VolumeAttachmentStatus", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattributesclasses": { + "delete": { + "description": "delete collection of VolumeAttributesClass", + "operationId": "deleteStorageV1CollectionVolumeAttributesClass", + "parameters": [ + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "deletecollection", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "get": { + "description": "list or watch objects of kind VolumeAttributesClass", + "operationId": "listStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "list", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "post": { + "description": "create a VolumeAttributesClass", + "operationId": "createStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "202": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "post", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}": { + "delete": { + "description": "delete a VolumeAttributesClass", + "operationId": "deleteStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.", + "in": "query", + "name": "gracePeriodSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it", + "in": "query", + "name": "ignoreStoreReadErrorWithClusterBreakingPotential", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.", + "in": "query", + "name": "orphanDependents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.", + "in": "query", + "name": "propagationPolicy", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions" + } + } + } + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "OK" + }, + "202": { + "content": { + "application/cbor": { + "schema": {} + }, + "application/json": { + "schema": {} + }, + "application/vnd.kubernetes.protobuf": { + "schema": {} + }, + "application/yaml": { + "schema": {} + } + }, + "description": "Accepted" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "delete", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "get": { + "description": "read the specified VolumeAttributesClass", + "operationId": "readStorageV1VolumeAttributesClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "get", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "name of the VolumeAttributesClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "patch": { + "description": "partially update the specified VolumeAttributesClass", + "operationId": "patchStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "in": "query", + "name": "force", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/apply-patch+cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/apply-patch+yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/json-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch" + } + }, + "application/merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + }, + "application/strategic-merge-patch+json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "patch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "put": { + "description": "replace the specified VolumeAttributesClass", + "operationId": "replaceStorageV1VolumeAttributesClass", + "parameters": [ + { + "description": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "in": "query", + "name": "dryRun", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "in": "query", + "name": "fieldManager", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.", + "in": "query", + "name": "fieldValidation", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "OK" + }, + "201": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass" + } + } + }, + "description": "Created" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "put", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + } + }, + "/apis/storage.k8s.io/v1/watch/csidrivers": { + "get": { + "description": "watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSIDriverList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csidrivers/{name}": { + "get": { + "description": "watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1CSIDriver", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIDriver", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSIDriver", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csinodes": { + "get": { + "description": "watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSINodeList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csinodes/{name}": { + "get": { + "description": "watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1CSINode", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSINode", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSINode", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/csistoragecapacities": { + "get": { + "description": "watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1CSIStorageCapacityListForAllNamespaces", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities": { + "get": { + "description": "watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1NamespacedCSIStorageCapacityList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}": { + "get": { + "description": "watch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1NamespacedCSIStorageCapacity", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "CSIStorageCapacity", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the CSIStorageCapacity", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "object name and auth scope, such as for teams and projects", + "in": "path", + "name": "namespace", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/storageclasses": { + "get": { + "description": "watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1StorageClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/storageclasses/{name}": { + "get": { + "description": "watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1StorageClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "StorageClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the StorageClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattachments": { + "get": { + "description": "watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1VolumeAttachmentList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattachments/{name}": { + "get": { + "description": "watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1VolumeAttachment", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttachment", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the VolumeAttachment", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattributesclasses": { + "get": { + "description": "watch individual changes to a list of VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead.", + "operationId": "watchStorageV1VolumeAttributesClassList", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watchlist", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + } + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + }, + "/apis/storage.k8s.io/v1/watch/volumeattributesclasses/{name}": { + "get": { + "description": "watch changes to an object of kind VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.", + "operationId": "watchStorageV1VolumeAttributesClass", + "responses": { + "200": { + "content": { + "application/cbor": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/cbor-seq": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/json;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/vnd.kubernetes.protobuf;stream=watch": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + }, + "application/yaml": { + "schema": { + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent" + } + } + }, + "description": "OK" + }, + "401": { + "description": "Unauthorized" + } + }, + "tags": [ + "storage_v1" + ], + "x-kubernetes-action": "watch", + "x-kubernetes-group-version-kind": { + "group": "storage.k8s.io", + "kind": "VolumeAttributesClass", + "version": "v1" + }, + "parameters": [ + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + } + ] + }, + "parameters": [ + { + "description": "allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.", + "in": "query", + "name": "allowWatchBookmarks", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\".\n\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.", + "in": "query", + "name": "continue", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their fields. Defaults to everything.", + "in": "query", + "name": "fieldSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "A selector to restrict the list of returned objects by their labels. Defaults to everything.", + "in": "query", + "name": "labelSelector", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\n\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.", + "in": "query", + "name": "limit", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "name of the VolumeAttributesClass", + "in": "path", + "name": "name", + "required": true, + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).", + "in": "query", + "name": "pretty", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersion", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\n\nDefaults to unset", + "in": "query", + "name": "resourceVersionMatch", + "schema": { + "type": "string", + "uniqueItems": true + } + }, + { + "description": "`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\n\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\n is interpreted as \"data at least as new as the provided `resourceVersion`\"\n and the bookmark event is send when the state is synced\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\n If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the\n bookmark event is send when the state is synced at least to the moment\n when request started being processed.\n- `resourceVersionMatch` set to any other value or unset\n Invalid error is returned.\n\nDefaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.", + "in": "query", + "name": "sendInitialEvents", + "schema": { + "type": "boolean", + "uniqueItems": true + } + }, + { + "description": "Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.", + "in": "query", + "name": "timeoutSeconds", + "schema": { + "type": "integer", + "uniqueItems": true + } + }, + { + "description": "Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.", + "in": "query", + "name": "watch", + "schema": { + "type": "boolean", + "uniqueItems": true + } + } + ] + } + } +} diff --git a/gen/openapi_v1_prototype/README.md b/gen/openapi_v1_prototype/README.md new file mode 100644 index 00000000..38b86b62 --- /dev/null +++ b/gen/openapi_v1_prototype/README.md @@ -0,0 +1,74 @@ +# OpenAPI.jl 1.0 bake-pipeline prototype + +Companion to [`../../OpenAPIv1RewriteNotes.md`](../../OpenAPIv1RewriteNotes.md). +Prototyped 2026-08-10 against OpenAPI.jl PR 103 at head `bd96d53`, +re-verified at `c2a5244` and `1ff9ba8` (2026-08-12); all live tests passed +against a k3s v1.35 cluster (`k8sbaked.jl` 8/8, `k8spristine_v3.jl` 11/11 — +the latter exercises the unpatched-spec route: tolerant decoding and the +watch-codec behavior including the `1ff9ba8` accept-scoped codec on a shared +client, and needs no spec patching, just steps 1 and 4 below with the +pristine document generated as `K8sCoreV1`). + +## Re-running it + +Requirements: Julia ≥ 1.11, a checkout of the OpenAPI.jl PR branch, `jq`, +`kubectl` pointed at a test cluster you can create/delete configmaps in. + +```sh +# 1. Get the pristine spec (match your cluster version, or pull from the cluster) +curl -sL -o api__v1_openapi.json \ + https://raw.githubusercontent.com/kubernetes/kubernetes/master/api/openapi-spec/v3/api__v1_openapi.json +# (alternative, exact match to the cluster:) +# kubectl get --raw /openapi/v3/api/v1 > api__v1_openapi.json + +# 2. Patch (nullable Time/MicroTime + nullable arrays + /watch/ paths -> WatchEvent) +jq -f patch_k8s_spec.jq api__v1_openapi.json > api__v1_patched.json + +# 3. Generate (strict mode is the default; ~5s cold / ~3s warm, ~6.7 MiB output) +julia --project= -e ' + using OpenAPI, HTTP + OpenAPI.client("api__v1_patched.json"; name = "K8sCoreV1P", path = "K8sCoreV1P.jl")' + +# 4. Live test (expects the generated K8sCoreV1P.jl in this directory) +kubectl proxy --port=8801 & +julia --project= k8sbaked.jl +``` + +`k8sbaked.jl` verifies, with full validation on: + +- pod list across all namespaces decodes, `lastProbeTime: null` arriving as + `nothing` (fails hard with the pristine spec); +- a live configmap watch through the dedicated `/watch/` operation decodes typed + `WatchEvent`s (an ADDED and a DELETED triggered via kubectl mid-watch); +- `close(channel)` cancels the watch. + +Why `/watch/` paths instead of `list(...; watch=true)`: k8s always replies +`Content-Type: application/json` regardless of `Accept`, and one OpenAPI +operation cannot describe both the List shape and WatchEvent frames — see +section 4 of the notes. Since `1ff9ba8` there is a patch-free alternative for +watch: register `codec!(client, "application/json;stream=watch"; decode=...)` +and pass `accept="application/json;stream=watch"` on `list(...; watch=true)` +calls — see section 5 of the notes; `k8spristine_v3.jl` covers it live. + +## The all-groups sweep + +`smoke_groups.jl` extends the pipeline to **every** OpenAPI v3 group document +the cluster serves (27 on k3s v1.35, including CRD-backed groups and the +aggregated metrics API). Verified 2026-08-12 at `1ff9ba8`: 27/27 patch + +strict generate (~39s, ~30 MiB), all modules co-load, 74/74 strict live list +ops (854 items), typed apps/v1 watch 5/5. + +```sh +mkdir -p groups +curl -s http://127.0.0.1:8801/openapi/v3 \ + | jq -r '.paths | keys[]' \ + | grep -E '^(api/v[0-9]+|apis/[^/]+/v[0-9a-z]+)$' \ + | while read p; do + curl -s "http://127.0.0.1:8801/openapi/v3/$p" -o "groups/$(echo $p | tr '/' '_').json" + jq -f patch_k8s_spec.jq "groups/$(echo $p | tr '/' '_').json" \ + > "groups/$(echo $p | tr '/' '_')_patched.json" + done +# generate each patched doc as K8s (see smoke_groups.jl for +# the module-name convention), then: +julia --project= smoke_groups.jl +``` diff --git a/gen/openapi_v1_prototype/k8sbaked.jl b/gen/openapi_v1_prototype/k8sbaked.jl new file mode 100644 index 00000000..fac75762 --- /dev/null +++ b/gen/openapi_v1_prototype/k8sbaked.jl @@ -0,0 +1,47 @@ +using Test +include("K8sCoreV1P.jl") +using .K8sCoreV1P +const K = K8sCoreV1P + +# full validation ON — the point of the patched bake is that defaults now work +client = K.Client("http://127.0.0.1:8801"; require_credentials=false) + +@testset "baked patched client vs live cluster" begin + @testset "pod list decodes (nullable Time fix)" begin + pods = K.listcorev1podforallnamespaces(; client, limit=Int64(50)) + @test pods isa K.IoK8sApiCoreV1PodList + println(" pods: ", length(pods.items)) + conds = [c for p in pods.items if !(p.status isa K.Absent) && !(p.status.conditions isa K.Absent) for c in p.status.conditions] + nulls = count(c -> c.lastprobetime === nothing, conds) + println(" conditions: ", length(conds), " (", nulls, " with lastProbeTime=null)") + @test !isempty(conds) && nulls > 0 # the previously-fatal nulls decode as `nothing` + end + + @testset "watch decodes WatchEvent (schema patch)" begin + cms = K.listcorev1namespacedconfigmap("default"; client) + events = Channel{Any}(16) + K.watchcorev1namespacedconfigmaplist("default"; client, + resourceversion=cms.metadata.resourceversion, stream_to=events) + run(`kubectl delete configmap baked-watch-test -n default --ignore-not-found`) + run(`kubectl create configmap baked-watch-test --from-literal=k=v -n default`) + wait_ok = timedwait(() -> isready(events) || !isopen(events), 20.0) + println(" wait: ", wait_ok, " isready=", isready(events), " isopen=", isopen(events)) + e = take!(events) # surfaces close-with-error if the stream failed + println(" event: ", typeof(e).name.name, " type=", e.type_, " name=", e.object.additional_properties["metadata"]["name"]) + @test e isa K.IoK8sApimachineryPkgApisMetaV1WatchEvent + @test e.type_ == "ADDED" + @test e.object.additional_properties["metadata"]["name"] == "baked-watch-test" + + # a second live event on the same stream + run(`kubectl delete configmap baked-watch-test -n default`) + @test timedwait(() -> isready(events), 20.0) == :ok + e2 = take!(events) + println(" event: type=", e2.type_, " name=", e2.object.additional_properties["metadata"]["name"]) + @test e2.type_ == "DELETED" + + close(events) # consumer-side cancel + sleep(2) + @test !isopen(events) + end +end +println("BAKED DONE") diff --git a/gen/openapi_v1_prototype/k8spristine_v3.jl b/gen/openapi_v1_prototype/k8spristine_v3.jl new file mode 100644 index 00000000..8479c3ba --- /dev/null +++ b/gen/openapi_v1_prototype/k8spristine_v3.jl @@ -0,0 +1,73 @@ +using Test, JSON +include("K8sCoreV1.jl") # PRISTINE spec — no patches +using .K8sCoreV1 +const K = K8sCoreV1 + +@testset "pristine spec + fd4558c leniency vs live cluster" begin + @testset "strict client still rejects (expected)" begin + strict = K.Client("http://127.0.0.1:8801"; require_credentials=false) + @test_throws K.SchemaValidationError K.listcorev1podforallnamespaces(; client=strict, limit=Int64(20)) + end + + @testset "tolerant client decodes pods (null Time -> nothing)" begin + tolerant = K.Client("http://127.0.0.1:8801"; require_credentials=false, validate_responses=false) + pods = K.listcorev1podforallnamespaces(; client=tolerant, limit=Int64(50)) + @test pods isa K.IoK8sApiCoreV1PodList + conds = [c for p in pods.items if !(p.status isa K.Absent) && !(p.status.conditions isa K.Absent) for c in p.status.conditions] + nulls = count(c -> c.lastprobetime === nothing, conds) + println(" pods=", length(pods.items), " conditions=", length(conds), " null lastProbeTime=", nulls) + @test nulls > 0 + end + + @testset "watch codec: parameterized key vs real k8s content-type" begin + # k8s replies plain application/json, so the parameterized registration should NOT fire + c1 = K.Client("http://127.0.0.1:8801"; require_credentials=false, validate_responses=false) + K.codec!(c1, "application/json;stream=watch"; decode=(bytes, media) -> (:codec_fired, JSON.parse(String(bytes)))) + cms = K.listcorev1namespacedconfigmap("default"; client=c1) + events = Channel{Any}(16) + K.listcorev1namespacedconfigmap("default"; client=c1, watch=true, + resourceversion=cms.metadata.resourceversion, stream_to=events) + run(`kubectl delete configmap v3-watch-test -n default --ignore-not-found`) + run(`kubectl create configmap v3-watch-test --from-literal=k=v -n default`) + timedwait(() -> isready(events) || !isopen(events), 15.0) + r1 = try take!(events) catch e; e end + fired = r1 isa Tuple && r1[1] === :codec_fired + println(" parameterized codec fired on real k8s: ", fired, " (got ", typeof(r1), ")") + close(events) + + # NEW at 1ff9ba8: same shared client, parameterized codec + accept= -> fires + events_a = Channel{Any}(16) + K.listcorev1namespacedconfigmap("default"; client=c1, watch=true, + resourceversion=cms.metadata.resourceversion, + accept="application/json;stream=watch", stream_to=events_a) + run(`kubectl delete configmap v3-watch-test -n default --ignore-not-found`) + run(`kubectl create configmap v3-watch-test --from-literal=k=v -n default`) + @test timedwait(() -> isready(events_a), 15.0) == :ok + ra = take!(events_a) + println(" accept-scoped codec fired on shared client: ", ra isa Tuple && ra[1] === :codec_fired) + @test ra isa Tuple && ra[1] === :codec_fired + ev = ra[2] + @test ev["type"] in ("ADDED","MODIFIED","DELETED") + @test ev["object"]["metadata"]["name"] == "v3-watch-test" + close(events_a) + + # ... and buffered calls on that same client are untouched by the codec + cms_again = K.listcorev1namespacedconfigmap("default"; client=c1) + @test cms_again isa K.IoK8sApiCoreV1ConfigMapList + + # plain-json codec on a DEDICATED watch client: should fire + c2 = K.Client("http://127.0.0.1:8801"; require_credentials=false, validate_responses=false) + K.codec!(c2, "application/json"; decode=(bytes, media) -> JSON.parse(String(bytes))) + events2 = Channel{Any}(16) + K.listcorev1namespacedconfigmap("default"; client=c2, watch=true, + resourceversion=cms.metadata.resourceversion, stream_to=events2) + @test timedwait(() -> isready(events2), 15.0) == :ok + e = take!(events2) + println(" plain-json codec item: ", typeof(e), " type=", get(e, "type", nothing), " name=", get(get(e, "object", Dict()), "metadata", Dict())["name"]) + @test e isa AbstractDict && e["type"] in ("ADDED","MODIFIED","DELETED") + @test e["object"]["metadata"]["name"] == "v3-watch-test" + close(events2) + run(`kubectl delete configmap v3-watch-test -n default --ignore-not-found`) + end +end +println("PRISTINE V3 DONE") diff --git a/gen/openapi_v1_prototype/patch_k8s_spec.jq b/gen/openapi_v1_prototype/patch_k8s_spec.jq new file mode 100644 index 00000000..997dce07 --- /dev/null +++ b/gen/openapi_v1_prototype/patch_k8s_spec.jq @@ -0,0 +1,20 @@ +# Bake-pipeline spec patch, robust across k8s group documents: +# 1. meta.v1.Time and meta.v1.MicroTime nullable (wire: lastProbeTime/eventTime +# arrive as explicit null) — only when the schema is present in the document +# 2. every array-typed property nullable: Go marshals nil slices as JSON null, +# so ANY array can arrive as null even when the spec calls it required +# (seen live: CSINodeSpec.drivers) +# 3. every dedicated /watch/ path's application/json response schema -> WatchEvent +(if (.components.schemas | has("io.k8s.apimachinery.pkg.apis.meta.v1.Time")) + then .components.schemas."io.k8s.apimachinery.pkg.apis.meta.v1.Time".nullable = true + else . end) +| (if (.components.schemas | has("io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime")) + then .components.schemas."io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime".nullable = true + else . end) +| (.components.schemas[] | objects | .properties // empty | .[] + | objects | select(.type == "array")).nullable = true +| reduce (.paths | keys[] | select(contains("/watch/"))) as $p (.; + (.paths[$p][] | objects | select(has("responses")) | .responses[] + | select(has("content")) | .content + | select(has("application/json")) | ."application/json".schema) + |= {"$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"}) diff --git a/gen/openapi_v1_prototype/smoke_groups.jl b/gen/openapi_v1_prototype/smoke_groups.jl new file mode 100644 index 00000000..a96b55d8 --- /dev/null +++ b/gen/openapi_v1_prototype/smoke_groups.jl @@ -0,0 +1,68 @@ +# Live smoke test: load all 27 generated group modules, call every +# zero-positional-arg list operation with a STRICT client (validation on), +# then one typed watch through a patched /watch/ path on apps/v1. +using Test + +const SERVER = "http://127.0.0.1:8801" +const MODS = sort(filter(f -> startswith(f, "K8s") && endswith(f, ".jl"), readdir("groups"))) + +loaded = Module[] +@testset "load all generated group modules" begin + for f in MODS + m = include(joinpath("groups", f)) + @test m isa Module + push!(loaded, m) + end + println(" loaded $(length(loaded)) modules") +end + +# every list operation that needs no positional args (cluster-scoped or +# for-all-namespaces), called with strict validation +total_ops = 0; total_items = 0 +@testset "strict live list calls across all groups" begin + for m in loaded + client = m.Client(SERVER; require_credentials = false) + ops = filter(names(m; all = true)) do n + s = String(n) + startswith(s, "list") || return false + f = getfield(m, n) + f isa Function || return false + # single method, no required positional args (just the function itself) + mt = methods(f) + length(mt) == 1 && first(mt).nargs == 1 + end + for op in ops + f = getfield(m, op) + res = try + f(; client) + catch e + println(" FAILED $(nameof(m)).$op: ", sprint(showerror, e)[1:min(end, 300)]) + @test false + continue + end + n = hasproperty(res, :items) && !(res.items isa m.Absent) ? length(res.items) : 0 + global total_ops += 1; global total_items += n + @test true + end + end + println(" $(total_ops) list ops succeeded, $(total_items) items decoded strictly") +end + +@testset "typed watch via patched /watch/ path (apps/v1 deployments)" begin + A = loaded[findfirst(m -> nameof(m) == :K8sAppsV1, loaded)] + client = A.Client(SERVER; require_credentials = false) + deps = A.listappsv1namespaceddeployment("default"; client) + events = Channel{Any}(16) + A.watchappsv1namespaceddeploymentlist("default"; client, + resourceversion = deps.metadata.resourceversion, stream_to = events) + run(`kubectl delete deployment smoke-dep -n default --ignore-not-found`) + run(`kubectl create deployment smoke-dep --image=busybox -n default -- sleep 3600`) + @test timedwait(() -> isready(events), 20.0) == :ok + ev = take!(events) + @test ev isa A.IoK8sApimachineryPkgApisMetaV1WatchEvent + @test ev.type_ in ("ADDED", "MODIFIED", "DELETED") + println(" watch event: $(typeof(ev).name.name) type=$(ev.type_)") + close(events) + run(`kubectl delete deployment smoke-dep -n default --ignore-not-found`) +end +println("GROUP SMOKE DONE") diff --git a/src/ApiImpl/ApiImpl.jl b/src/ApiImpl/ApiImpl.jl index 496f0bba..c2923751 100644 --- a/src/ApiImpl/ApiImpl.jl +++ b/src/ApiImpl/ApiImpl.jl @@ -1,9 +1,22 @@ +""" +The generated layer: one OpenAPI.jl client module per Kubernetes API group +version, plus the registry tables that map k8s group-versions, kinds and verbs +onto them. + +Everything under `generated/` is machine-produced by the pipeline in +`gen/openapi_v1/` (fetch_specs.sh -> patch_k8s_spec.jq -> generate.jl -> +emit_registry.jl) from the checked-in specs. Do not hand-edit any of it — +generated output is byte-stable only for the pinned OpenAPI.jl commit, so a +pin move means a full regeneration. +""" module ApiImpl -include("api/Kubernetes.jl") -using .Kubernetes +const GENERATED = joinpath(@__DIR__, "generated") + +for f in sort(filter(f -> startswith(f, "K8s") && endswith(f, ".jl"), readdir(GENERATED))) + include(joinpath(GENERATED, f)) +end -include("api_typemap.jl") -include("api_versions.jl") +include(joinpath(GENERATED, "registry.jl")) end # module diff --git a/src/ApiImpl/api/Kubernetes.jl b/src/ApiImpl/api/Kubernetes.jl deleted file mode 100644 index b5694221..00000000 --- a/src/ApiImpl/api/Kubernetes.jl +++ /dev/null @@ -1,861 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -module Kubernetes - -using Dates, TimeZones -using OpenAPI -using OpenAPI.Clients - -const API_VERSION = "unversioned" - -include("modelincludes.jl") - -include("apis/api_AdmissionregistrationApi.jl") -include("apis/api_AdmissionregistrationV1Api.jl") -include("apis/api_AdmissionregistrationV1beta1Api.jl") -include("apis/api_ApiextensionsApi.jl") -include("apis/api_ApiextensionsV1Api.jl") -include("apis/api_ApiextensionsV1beta1Api.jl") -include("apis/api_ApiregistrationApi.jl") -include("apis/api_ApiregistrationV1Api.jl") -include("apis/api_ApiregistrationV1beta1Api.jl") -include("apis/api_ApisApi.jl") -include("apis/api_AppsApi.jl") -include("apis/api_AppsV1Api.jl") -include("apis/api_AppsV1beta1Api.jl") -include("apis/api_AppsV1beta2Api.jl") -include("apis/api_AuditregistrationApi.jl") -include("apis/api_AuditregistrationV1alpha1Api.jl") -include("apis/api_AuthenticationApi.jl") -include("apis/api_AuthenticationV1Api.jl") -include("apis/api_AuthenticationV1beta1Api.jl") -include("apis/api_AuthorizationApi.jl") -include("apis/api_AuthorizationV1Api.jl") -include("apis/api_AuthorizationV1beta1Api.jl") -include("apis/api_AutoscalingApi.jl") -include("apis/api_AutoscalingV1Api.jl") -include("apis/api_AutoscalingV2beta1Api.jl") -include("apis/api_AutoscalingV2beta2Api.jl") -include("apis/api_BatchApi.jl") -include("apis/api_BatchV1Api.jl") -include("apis/api_BatchV1beta1Api.jl") -include("apis/api_BatchV2alpha1Api.jl") -include("apis/api_CertificatesApi.jl") -include("apis/api_CertificatesV1beta1Api.jl") -include("apis/api_CoordinationApi.jl") -include("apis/api_CoordinationV1Api.jl") -include("apis/api_CoordinationV1beta1Api.jl") -include("apis/api_CoreApi.jl") -include("apis/api_CoreV1Api.jl") -include("apis/api_CustomMetricsV1beta1Api.jl") -include("apis/api_DiscoveryApi.jl") -include("apis/api_DiscoveryV1beta1Api.jl") -include("apis/api_EventsApi.jl") -include("apis/api_EventsV1beta1Api.jl") -include("apis/api_ExtensionsApi.jl") -include("apis/api_ExtensionsV1beta1Api.jl") -include("apis/api_FlowcontrolApiserverApi.jl") -include("apis/api_FlowcontrolApiserverV1alpha1Api.jl") -include("apis/api_KarpenterShV1alpha5Api.jl") -include("apis/api_LogsApi.jl") -include("apis/api_MetricsV1beta1Api.jl") -include("apis/api_NetworkingApi.jl") -include("apis/api_NetworkingV1Api.jl") -include("apis/api_NetworkingV1beta1Api.jl") -include("apis/api_NodeApi.jl") -include("apis/api_NodeV1alpha1Api.jl") -include("apis/api_NodeV1beta1Api.jl") -include("apis/api_PolicyApi.jl") -include("apis/api_PolicyV1beta1Api.jl") -include("apis/api_RbacAuthorizationApi.jl") -include("apis/api_RbacAuthorizationV1Api.jl") -include("apis/api_RbacAuthorizationV1alpha1Api.jl") -include("apis/api_RbacAuthorizationV1beta1Api.jl") -include("apis/api_SchedulingApi.jl") -include("apis/api_SchedulingV1Api.jl") -include("apis/api_SchedulingV1alpha1Api.jl") -include("apis/api_SchedulingV1beta1Api.jl") -include("apis/api_SettingsApi.jl") -include("apis/api_SettingsV1alpha1Api.jl") -include("apis/api_StorageApi.jl") -include("apis/api_StorageV1Api.jl") -include("apis/api_StorageV1alpha1Api.jl") -include("apis/api_StorageV1beta1Api.jl") -include("apis/api_VersionApi.jl") - -# export models -export IoK8sApiAdmissionregistrationV1MutatingWebhook -export IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration -export IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList -export IoK8sApiAdmissionregistrationV1RuleWithOperations -export IoK8sApiAdmissionregistrationV1ServiceReference -export IoK8sApiAdmissionregistrationV1ValidatingWebhook -export IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration -export IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList -export IoK8sApiAdmissionregistrationV1WebhookClientConfig -export IoK8sApiAdmissionregistrationV1beta1MutatingWebhook -export IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration -export IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList -export IoK8sApiAdmissionregistrationV1beta1RuleWithOperations -export IoK8sApiAdmissionregistrationV1beta1ServiceReference -export IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook -export IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration -export IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList -export IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig -export IoK8sApiAppsV1ControllerRevision -export IoK8sApiAppsV1ControllerRevisionList -export IoK8sApiAppsV1DaemonSet -export IoK8sApiAppsV1DaemonSetCondition -export IoK8sApiAppsV1DaemonSetList -export IoK8sApiAppsV1DaemonSetSpec -export IoK8sApiAppsV1DaemonSetStatus -export IoK8sApiAppsV1DaemonSetUpdateStrategy -export IoK8sApiAppsV1Deployment -export IoK8sApiAppsV1DeploymentCondition -export IoK8sApiAppsV1DeploymentList -export IoK8sApiAppsV1DeploymentSpec -export IoK8sApiAppsV1DeploymentStatus -export IoK8sApiAppsV1DeploymentStrategy -export IoK8sApiAppsV1ReplicaSet -export IoK8sApiAppsV1ReplicaSetCondition -export IoK8sApiAppsV1ReplicaSetList -export IoK8sApiAppsV1ReplicaSetSpec -export IoK8sApiAppsV1ReplicaSetStatus -export IoK8sApiAppsV1RollingUpdateDaemonSet -export IoK8sApiAppsV1RollingUpdateDeployment -export IoK8sApiAppsV1RollingUpdateStatefulSetStrategy -export IoK8sApiAppsV1StatefulSet -export IoK8sApiAppsV1StatefulSetCondition -export IoK8sApiAppsV1StatefulSetList -export IoK8sApiAppsV1StatefulSetSpec -export IoK8sApiAppsV1StatefulSetStatus -export IoK8sApiAppsV1StatefulSetUpdateStrategy -export IoK8sApiAppsV1beta1ControllerRevision -export IoK8sApiAppsV1beta1ControllerRevisionList -export IoK8sApiAppsV1beta1Deployment -export IoK8sApiAppsV1beta1DeploymentCondition -export IoK8sApiAppsV1beta1DeploymentList -export IoK8sApiAppsV1beta1DeploymentRollback -export IoK8sApiAppsV1beta1DeploymentSpec -export IoK8sApiAppsV1beta1DeploymentStatus -export IoK8sApiAppsV1beta1DeploymentStrategy -export IoK8sApiAppsV1beta1RollbackConfig -export IoK8sApiAppsV1beta1RollingUpdateDeployment -export IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy -export IoK8sApiAppsV1beta1Scale -export IoK8sApiAppsV1beta1ScaleSpec -export IoK8sApiAppsV1beta1ScaleStatus -export IoK8sApiAppsV1beta1StatefulSet -export IoK8sApiAppsV1beta1StatefulSetCondition -export IoK8sApiAppsV1beta1StatefulSetList -export IoK8sApiAppsV1beta1StatefulSetSpec -export IoK8sApiAppsV1beta1StatefulSetStatus -export IoK8sApiAppsV1beta1StatefulSetUpdateStrategy -export IoK8sApiAppsV1beta2ControllerRevision -export IoK8sApiAppsV1beta2ControllerRevisionList -export IoK8sApiAppsV1beta2DaemonSet -export IoK8sApiAppsV1beta2DaemonSetCondition -export IoK8sApiAppsV1beta2DaemonSetList -export IoK8sApiAppsV1beta2DaemonSetSpec -export IoK8sApiAppsV1beta2DaemonSetStatus -export IoK8sApiAppsV1beta2DaemonSetUpdateStrategy -export IoK8sApiAppsV1beta2Deployment -export IoK8sApiAppsV1beta2DeploymentCondition -export IoK8sApiAppsV1beta2DeploymentList -export IoK8sApiAppsV1beta2DeploymentSpec -export IoK8sApiAppsV1beta2DeploymentStatus -export IoK8sApiAppsV1beta2DeploymentStrategy -export IoK8sApiAppsV1beta2ReplicaSet -export IoK8sApiAppsV1beta2ReplicaSetCondition -export IoK8sApiAppsV1beta2ReplicaSetList -export IoK8sApiAppsV1beta2ReplicaSetSpec -export IoK8sApiAppsV1beta2ReplicaSetStatus -export IoK8sApiAppsV1beta2RollingUpdateDaemonSet -export IoK8sApiAppsV1beta2RollingUpdateDeployment -export IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy -export IoK8sApiAppsV1beta2Scale -export IoK8sApiAppsV1beta2ScaleSpec -export IoK8sApiAppsV1beta2ScaleStatus -export IoK8sApiAppsV1beta2StatefulSet -export IoK8sApiAppsV1beta2StatefulSetCondition -export IoK8sApiAppsV1beta2StatefulSetList -export IoK8sApiAppsV1beta2StatefulSetSpec -export IoK8sApiAppsV1beta2StatefulSetStatus -export IoK8sApiAppsV1beta2StatefulSetUpdateStrategy -export IoK8sApiAuditregistrationV1alpha1AuditSink -export IoK8sApiAuditregistrationV1alpha1AuditSinkList -export IoK8sApiAuditregistrationV1alpha1AuditSinkSpec -export IoK8sApiAuditregistrationV1alpha1Policy -export IoK8sApiAuditregistrationV1alpha1ServiceReference -export IoK8sApiAuditregistrationV1alpha1Webhook -export IoK8sApiAuditregistrationV1alpha1WebhookClientConfig -export IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig -export IoK8sApiAuthenticationV1BoundObjectReference -export IoK8sApiAuthenticationV1TokenRequest -export IoK8sApiAuthenticationV1TokenRequestSpec -export IoK8sApiAuthenticationV1TokenRequestStatus -export IoK8sApiAuthenticationV1TokenReview -export IoK8sApiAuthenticationV1TokenReviewSpec -export IoK8sApiAuthenticationV1TokenReviewStatus -export IoK8sApiAuthenticationV1UserInfo -export IoK8sApiAuthenticationV1beta1TokenReview -export IoK8sApiAuthenticationV1beta1TokenReviewSpec -export IoK8sApiAuthenticationV1beta1TokenReviewStatus -export IoK8sApiAuthenticationV1beta1UserInfo -export IoK8sApiAuthorizationV1LocalSubjectAccessReview -export IoK8sApiAuthorizationV1NonResourceAttributes -export IoK8sApiAuthorizationV1NonResourceRule -export IoK8sApiAuthorizationV1ResourceAttributes -export IoK8sApiAuthorizationV1ResourceRule -export IoK8sApiAuthorizationV1SelfSubjectAccessReview -export IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec -export IoK8sApiAuthorizationV1SelfSubjectRulesReview -export IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec -export IoK8sApiAuthorizationV1SubjectAccessReview -export IoK8sApiAuthorizationV1SubjectAccessReviewSpec -export IoK8sApiAuthorizationV1SubjectAccessReviewStatus -export IoK8sApiAuthorizationV1SubjectRulesReviewStatus -export IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview -export IoK8sApiAuthorizationV1beta1NonResourceAttributes -export IoK8sApiAuthorizationV1beta1NonResourceRule -export IoK8sApiAuthorizationV1beta1ResourceAttributes -export IoK8sApiAuthorizationV1beta1ResourceRule -export IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview -export IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec -export IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview -export IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec -export IoK8sApiAuthorizationV1beta1SubjectAccessReview -export IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec -export IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus -export IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus -export IoK8sApiAutoscalingV1CrossVersionObjectReference -export IoK8sApiAutoscalingV1HorizontalPodAutoscaler -export IoK8sApiAutoscalingV1HorizontalPodAutoscalerList -export IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec -export IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus -export IoK8sApiAutoscalingV1Scale -export IoK8sApiAutoscalingV1ScaleSpec -export IoK8sApiAutoscalingV1ScaleStatus -export IoK8sApiAutoscalingV2beta1CrossVersionObjectReference -export IoK8sApiAutoscalingV2beta1ExternalMetricSource -export IoK8sApiAutoscalingV2beta1ExternalMetricStatus -export IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler -export IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition -export IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList -export IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec -export IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus -export IoK8sApiAutoscalingV2beta1MetricSpec -export IoK8sApiAutoscalingV2beta1MetricStatus -export IoK8sApiAutoscalingV2beta1ObjectMetricSource -export IoK8sApiAutoscalingV2beta1ObjectMetricStatus -export IoK8sApiAutoscalingV2beta1PodsMetricSource -export IoK8sApiAutoscalingV2beta1PodsMetricStatus -export IoK8sApiAutoscalingV2beta1ResourceMetricSource -export IoK8sApiAutoscalingV2beta1ResourceMetricStatus -export IoK8sApiAutoscalingV2beta2CrossVersionObjectReference -export IoK8sApiAutoscalingV2beta2ExternalMetricSource -export IoK8sApiAutoscalingV2beta2ExternalMetricStatus -export IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler -export IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition -export IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList -export IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec -export IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus -export IoK8sApiAutoscalingV2beta2MetricIdentifier -export IoK8sApiAutoscalingV2beta2MetricSpec -export IoK8sApiAutoscalingV2beta2MetricStatus -export IoK8sApiAutoscalingV2beta2MetricTarget -export IoK8sApiAutoscalingV2beta2MetricValueStatus -export IoK8sApiAutoscalingV2beta2ObjectMetricSource -export IoK8sApiAutoscalingV2beta2ObjectMetricStatus -export IoK8sApiAutoscalingV2beta2PodsMetricSource -export IoK8sApiAutoscalingV2beta2PodsMetricStatus -export IoK8sApiAutoscalingV2beta2ResourceMetricSource -export IoK8sApiAutoscalingV2beta2ResourceMetricStatus -export IoK8sApiBatchV1CronJob -export IoK8sApiBatchV1CronJobList -export IoK8sApiBatchV1CronJobSpec -export IoK8sApiBatchV1CronJobStatus -export IoK8sApiBatchV1Job -export IoK8sApiBatchV1JobCondition -export IoK8sApiBatchV1JobList -export IoK8sApiBatchV1JobSpec -export IoK8sApiBatchV1JobStatus -export IoK8sApiBatchV1JobTemplateSpec -export IoK8sApiBatchV1beta1CronJob -export IoK8sApiBatchV1beta1CronJobList -export IoK8sApiBatchV1beta1CronJobSpec -export IoK8sApiBatchV1beta1CronJobStatus -export IoK8sApiBatchV1beta1JobTemplateSpec -export IoK8sApiBatchV2alpha1CronJob -export IoK8sApiBatchV2alpha1CronJobList -export IoK8sApiBatchV2alpha1CronJobSpec -export IoK8sApiBatchV2alpha1CronJobStatus -export IoK8sApiBatchV2alpha1JobTemplateSpec -export IoK8sApiCertificatesV1beta1CertificateSigningRequest -export IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition -export IoK8sApiCertificatesV1beta1CertificateSigningRequestList -export IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec -export IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus -export IoK8sApiCoordinationV1Lease -export IoK8sApiCoordinationV1LeaseList -export IoK8sApiCoordinationV1LeaseSpec -export IoK8sApiCoordinationV1beta1Lease -export IoK8sApiCoordinationV1beta1LeaseList -export IoK8sApiCoordinationV1beta1LeaseSpec -export IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource -export IoK8sApiCoreV1Affinity -export IoK8sApiCoreV1AttachedVolume -export IoK8sApiCoreV1AzureDiskVolumeSource -export IoK8sApiCoreV1AzureFilePersistentVolumeSource -export IoK8sApiCoreV1AzureFileVolumeSource -export IoK8sApiCoreV1Binding -export IoK8sApiCoreV1CSIPersistentVolumeSource -export IoK8sApiCoreV1CSIVolumeSource -export IoK8sApiCoreV1Capabilities -export IoK8sApiCoreV1CephFSPersistentVolumeSource -export IoK8sApiCoreV1CephFSVolumeSource -export IoK8sApiCoreV1CinderPersistentVolumeSource -export IoK8sApiCoreV1CinderVolumeSource -export IoK8sApiCoreV1ClientIPConfig -export IoK8sApiCoreV1ComponentCondition -export IoK8sApiCoreV1ComponentStatus -export IoK8sApiCoreV1ComponentStatusList -export IoK8sApiCoreV1ConfigMap -export IoK8sApiCoreV1ConfigMapEnvSource -export IoK8sApiCoreV1ConfigMapKeySelector -export IoK8sApiCoreV1ConfigMapList -export IoK8sApiCoreV1ConfigMapNodeConfigSource -export IoK8sApiCoreV1ConfigMapProjection -export IoK8sApiCoreV1ConfigMapVolumeSource -export IoK8sApiCoreV1Container -export IoK8sApiCoreV1ContainerImage -export IoK8sApiCoreV1ContainerPort -export IoK8sApiCoreV1ContainerState -export IoK8sApiCoreV1ContainerStateRunning -export IoK8sApiCoreV1ContainerStateTerminated -export IoK8sApiCoreV1ContainerStateWaiting -export IoK8sApiCoreV1ContainerStatus -export IoK8sApiCoreV1DaemonEndpoint -export IoK8sApiCoreV1DownwardAPIProjection -export IoK8sApiCoreV1DownwardAPIVolumeFile -export IoK8sApiCoreV1DownwardAPIVolumeSource -export IoK8sApiCoreV1EmptyDirVolumeSource -export IoK8sApiCoreV1EndpointAddress -export IoK8sApiCoreV1EndpointPort -export IoK8sApiCoreV1EndpointSubset -export IoK8sApiCoreV1Endpoints -export IoK8sApiCoreV1EndpointsList -export IoK8sApiCoreV1EnvFromSource -export IoK8sApiCoreV1EnvVar -export IoK8sApiCoreV1EnvVarSource -export IoK8sApiCoreV1EphemeralContainer -export IoK8sApiCoreV1Event -export IoK8sApiCoreV1EventList -export IoK8sApiCoreV1EventSeries -export IoK8sApiCoreV1EventSource -export IoK8sApiCoreV1ExecAction -export IoK8sApiCoreV1FCVolumeSource -export IoK8sApiCoreV1FlexPersistentVolumeSource -export IoK8sApiCoreV1FlexVolumeSource -export IoK8sApiCoreV1FlockerVolumeSource -export IoK8sApiCoreV1GCEPersistentDiskVolumeSource -export IoK8sApiCoreV1GitRepoVolumeSource -export IoK8sApiCoreV1GlusterfsPersistentVolumeSource -export IoK8sApiCoreV1GlusterfsVolumeSource -export IoK8sApiCoreV1HTTPGetAction -export IoK8sApiCoreV1HTTPHeader -export IoK8sApiCoreV1Handler -export IoK8sApiCoreV1HostAlias -export IoK8sApiCoreV1HostPathVolumeSource -export IoK8sApiCoreV1ISCSIPersistentVolumeSource -export IoK8sApiCoreV1ISCSIVolumeSource -export IoK8sApiCoreV1KeyToPath -export IoK8sApiCoreV1Lifecycle -export IoK8sApiCoreV1LimitRange -export IoK8sApiCoreV1LimitRangeItem -export IoK8sApiCoreV1LimitRangeList -export IoK8sApiCoreV1LimitRangeSpec -export IoK8sApiCoreV1LoadBalancerIngress -export IoK8sApiCoreV1LoadBalancerStatus -export IoK8sApiCoreV1LocalObjectReference -export IoK8sApiCoreV1LocalVolumeSource -export IoK8sApiCoreV1NFSVolumeSource -export IoK8sApiCoreV1Namespace -export IoK8sApiCoreV1NamespaceCondition -export IoK8sApiCoreV1NamespaceList -export IoK8sApiCoreV1NamespaceSpec -export IoK8sApiCoreV1NamespaceStatus -export IoK8sApiCoreV1Node -export IoK8sApiCoreV1NodeAddress -export IoK8sApiCoreV1NodeAffinity -export IoK8sApiCoreV1NodeCondition -export IoK8sApiCoreV1NodeConfigSource -export IoK8sApiCoreV1NodeConfigStatus -export IoK8sApiCoreV1NodeDaemonEndpoints -export IoK8sApiCoreV1NodeList -export IoK8sApiCoreV1NodeSelector -export IoK8sApiCoreV1NodeSelectorRequirement -export IoK8sApiCoreV1NodeSelectorTerm -export IoK8sApiCoreV1NodeSpec -export IoK8sApiCoreV1NodeStatus -export IoK8sApiCoreV1NodeSystemInfo -export IoK8sApiCoreV1ObjectFieldSelector -export IoK8sApiCoreV1ObjectReference -export IoK8sApiCoreV1PersistentVolume -export IoK8sApiCoreV1PersistentVolumeClaim -export IoK8sApiCoreV1PersistentVolumeClaimCondition -export IoK8sApiCoreV1PersistentVolumeClaimList -export IoK8sApiCoreV1PersistentVolumeClaimSpec -export IoK8sApiCoreV1PersistentVolumeClaimStatus -export IoK8sApiCoreV1PersistentVolumeClaimVolumeSource -export IoK8sApiCoreV1PersistentVolumeList -export IoK8sApiCoreV1PersistentVolumeSpec -export IoK8sApiCoreV1PersistentVolumeStatus -export IoK8sApiCoreV1PhotonPersistentDiskVolumeSource -export IoK8sApiCoreV1Pod -export IoK8sApiCoreV1PodAffinity -export IoK8sApiCoreV1PodAffinityTerm -export IoK8sApiCoreV1PodAntiAffinity -export IoK8sApiCoreV1PodCondition -export IoK8sApiCoreV1PodDNSConfig -export IoK8sApiCoreV1PodDNSConfigOption -export IoK8sApiCoreV1PodIP -export IoK8sApiCoreV1PodList -export IoK8sApiCoreV1PodReadinessGate -export IoK8sApiCoreV1PodSecurityContext -export IoK8sApiCoreV1PodSpec -export IoK8sApiCoreV1PodStatus -export IoK8sApiCoreV1PodTemplate -export IoK8sApiCoreV1PodTemplateList -export IoK8sApiCoreV1PodTemplateSpec -export IoK8sApiCoreV1PortworxVolumeSource -export IoK8sApiCoreV1PreferredSchedulingTerm -export IoK8sApiCoreV1Probe -export IoK8sApiCoreV1ProjectedVolumeSource -export IoK8sApiCoreV1QuobyteVolumeSource -export IoK8sApiCoreV1RBDPersistentVolumeSource -export IoK8sApiCoreV1RBDVolumeSource -export IoK8sApiCoreV1ReplicationController -export IoK8sApiCoreV1ReplicationControllerCondition -export IoK8sApiCoreV1ReplicationControllerList -export IoK8sApiCoreV1ReplicationControllerSpec -export IoK8sApiCoreV1ReplicationControllerStatus -export IoK8sApiCoreV1ResourceFieldSelector -export IoK8sApiCoreV1ResourceQuota -export IoK8sApiCoreV1ResourceQuotaList -export IoK8sApiCoreV1ResourceQuotaSpec -export IoK8sApiCoreV1ResourceQuotaStatus -export IoK8sApiCoreV1ResourceRequirements -export IoK8sApiCoreV1SELinuxOptions -export IoK8sApiCoreV1ScaleIOPersistentVolumeSource -export IoK8sApiCoreV1ScaleIOVolumeSource -export IoK8sApiCoreV1ScopeSelector -export IoK8sApiCoreV1ScopedResourceSelectorRequirement -export IoK8sApiCoreV1Secret -export IoK8sApiCoreV1SecretEnvSource -export IoK8sApiCoreV1SecretKeySelector -export IoK8sApiCoreV1SecretList -export IoK8sApiCoreV1SecretProjection -export IoK8sApiCoreV1SecretReference -export IoK8sApiCoreV1SecretVolumeSource -export IoK8sApiCoreV1SecurityContext -export IoK8sApiCoreV1Service -export IoK8sApiCoreV1ServiceAccount -export IoK8sApiCoreV1ServiceAccountList -export IoK8sApiCoreV1ServiceAccountTokenProjection -export IoK8sApiCoreV1ServiceList -export IoK8sApiCoreV1ServicePort -export IoK8sApiCoreV1ServiceSpec -export IoK8sApiCoreV1ServiceStatus -export IoK8sApiCoreV1SessionAffinityConfig -export IoK8sApiCoreV1StorageOSPersistentVolumeSource -export IoK8sApiCoreV1StorageOSVolumeSource -export IoK8sApiCoreV1Sysctl -export IoK8sApiCoreV1TCPSocketAction -export IoK8sApiCoreV1Taint -export IoK8sApiCoreV1Toleration -export IoK8sApiCoreV1TopologySelectorLabelRequirement -export IoK8sApiCoreV1TopologySelectorTerm -export IoK8sApiCoreV1TopologySpreadConstraint -export IoK8sApiCoreV1TypedLocalObjectReference -export IoK8sApiCoreV1Volume -export IoK8sApiCoreV1VolumeDevice -export IoK8sApiCoreV1VolumeMount -export IoK8sApiCoreV1VolumeNodeAffinity -export IoK8sApiCoreV1VolumeProjection -export IoK8sApiCoreV1VsphereVirtualDiskVolumeSource -export IoK8sApiCoreV1WeightedPodAffinityTerm -export IoK8sApiCoreV1WindowsSecurityContextOptions -export IoK8sApiCustomMetricsV1beta1MetricValue -export IoK8sApiCustomMetricsV1beta1MetricValueList -export IoK8sApiDiscoveryV1beta1Endpoint -export IoK8sApiDiscoveryV1beta1EndpointConditions -export IoK8sApiDiscoveryV1beta1EndpointPort -export IoK8sApiDiscoveryV1beta1EndpointSlice -export IoK8sApiDiscoveryV1beta1EndpointSliceList -export IoK8sApiEventsV1beta1Event -export IoK8sApiEventsV1beta1EventList -export IoK8sApiEventsV1beta1EventSeries -export IoK8sApiExtensionsV1beta1AllowedCSIDriver -export IoK8sApiExtensionsV1beta1AllowedFlexVolume -export IoK8sApiExtensionsV1beta1AllowedHostPath -export IoK8sApiExtensionsV1beta1DaemonSet -export IoK8sApiExtensionsV1beta1DaemonSetCondition -export IoK8sApiExtensionsV1beta1DaemonSetList -export IoK8sApiExtensionsV1beta1DaemonSetSpec -export IoK8sApiExtensionsV1beta1DaemonSetStatus -export IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy -export IoK8sApiExtensionsV1beta1Deployment -export IoK8sApiExtensionsV1beta1DeploymentCondition -export IoK8sApiExtensionsV1beta1DeploymentList -export IoK8sApiExtensionsV1beta1DeploymentRollback -export IoK8sApiExtensionsV1beta1DeploymentSpec -export IoK8sApiExtensionsV1beta1DeploymentStatus -export IoK8sApiExtensionsV1beta1DeploymentStrategy -export IoK8sApiExtensionsV1beta1FSGroupStrategyOptions -export IoK8sApiExtensionsV1beta1HTTPIngressPath -export IoK8sApiExtensionsV1beta1HTTPIngressRuleValue -export IoK8sApiExtensionsV1beta1HostPortRange -export IoK8sApiExtensionsV1beta1IDRange -export IoK8sApiExtensionsV1beta1IPBlock -export IoK8sApiExtensionsV1beta1Ingress -export IoK8sApiExtensionsV1beta1IngressBackend -export IoK8sApiExtensionsV1beta1IngressList -export IoK8sApiExtensionsV1beta1IngressRule -export IoK8sApiExtensionsV1beta1IngressSpec -export IoK8sApiExtensionsV1beta1IngressStatus -export IoK8sApiExtensionsV1beta1IngressTLS -export IoK8sApiExtensionsV1beta1NetworkPolicy -export IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule -export IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule -export IoK8sApiExtensionsV1beta1NetworkPolicyList -export IoK8sApiExtensionsV1beta1NetworkPolicyPeer -export IoK8sApiExtensionsV1beta1NetworkPolicyPort -export IoK8sApiExtensionsV1beta1NetworkPolicySpec -export IoK8sApiExtensionsV1beta1PodSecurityPolicy -export IoK8sApiExtensionsV1beta1PodSecurityPolicyList -export IoK8sApiExtensionsV1beta1PodSecurityPolicySpec -export IoK8sApiExtensionsV1beta1ReplicaSet -export IoK8sApiExtensionsV1beta1ReplicaSetCondition -export IoK8sApiExtensionsV1beta1ReplicaSetList -export IoK8sApiExtensionsV1beta1ReplicaSetSpec -export IoK8sApiExtensionsV1beta1ReplicaSetStatus -export IoK8sApiExtensionsV1beta1RollbackConfig -export IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet -export IoK8sApiExtensionsV1beta1RollingUpdateDeployment -export IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions -export IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions -export IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions -export IoK8sApiExtensionsV1beta1SELinuxStrategyOptions -export IoK8sApiExtensionsV1beta1Scale -export IoK8sApiExtensionsV1beta1ScaleSpec -export IoK8sApiExtensionsV1beta1ScaleStatus -export IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions -export IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod -export IoK8sApiFlowcontrolV1alpha1FlowSchema -export IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition -export IoK8sApiFlowcontrolV1alpha1FlowSchemaList -export IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec -export IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus -export IoK8sApiFlowcontrolV1alpha1GroupSubject -export IoK8sApiFlowcontrolV1alpha1LimitResponse -export IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration -export IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule -export IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec -export IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus -export IoK8sApiFlowcontrolV1alpha1QueuingConfiguration -export IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule -export IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject -export IoK8sApiFlowcontrolV1alpha1Subject -export IoK8sApiFlowcontrolV1alpha1UserSubject -export IoK8sApiMetricsV1beta1ContainerMetrics -export IoK8sApiMetricsV1beta1NodeMetrics -export IoK8sApiMetricsV1beta1NodeMetricsList -export IoK8sApiMetricsV1beta1PodMetrics -export IoK8sApiMetricsV1beta1PodMetricsList -export IoK8sApiNetworkingV1IPBlock -export IoK8sApiNetworkingV1NetworkPolicy -export IoK8sApiNetworkingV1NetworkPolicyEgressRule -export IoK8sApiNetworkingV1NetworkPolicyIngressRule -export IoK8sApiNetworkingV1NetworkPolicyList -export IoK8sApiNetworkingV1NetworkPolicyPeer -export IoK8sApiNetworkingV1NetworkPolicyPort -export IoK8sApiNetworkingV1NetworkPolicySpec -export IoK8sApiNetworkingV1beta1HTTPIngressPath -export IoK8sApiNetworkingV1beta1HTTPIngressRuleValue -export IoK8sApiNetworkingV1beta1Ingress -export IoK8sApiNetworkingV1beta1IngressBackend -export IoK8sApiNetworkingV1beta1IngressList -export IoK8sApiNetworkingV1beta1IngressRule -export IoK8sApiNetworkingV1beta1IngressSpec -export IoK8sApiNetworkingV1beta1IngressStatus -export IoK8sApiNetworkingV1beta1IngressTLS -export IoK8sApiNodeV1alpha1Overhead -export IoK8sApiNodeV1alpha1RuntimeClass -export IoK8sApiNodeV1alpha1RuntimeClassList -export IoK8sApiNodeV1alpha1RuntimeClassSpec -export IoK8sApiNodeV1alpha1Scheduling -export IoK8sApiNodeV1beta1Overhead -export IoK8sApiNodeV1beta1RuntimeClass -export IoK8sApiNodeV1beta1RuntimeClassList -export IoK8sApiNodeV1beta1Scheduling -export IoK8sApiPolicyV1beta1AllowedCSIDriver -export IoK8sApiPolicyV1beta1AllowedFlexVolume -export IoK8sApiPolicyV1beta1AllowedHostPath -export IoK8sApiPolicyV1beta1Eviction -export IoK8sApiPolicyV1beta1FSGroupStrategyOptions -export IoK8sApiPolicyV1beta1HostPortRange -export IoK8sApiPolicyV1beta1IDRange -export IoK8sApiPolicyV1beta1PodDisruptionBudget -export IoK8sApiPolicyV1beta1PodDisruptionBudgetList -export IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec -export IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus -export IoK8sApiPolicyV1beta1PodSecurityPolicy -export IoK8sApiPolicyV1beta1PodSecurityPolicyList -export IoK8sApiPolicyV1beta1PodSecurityPolicySpec -export IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions -export IoK8sApiPolicyV1beta1RunAsUserStrategyOptions -export IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions -export IoK8sApiPolicyV1beta1SELinuxStrategyOptions -export IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions -export IoK8sApiRbacV1AggregationRule -export IoK8sApiRbacV1ClusterRole -export IoK8sApiRbacV1ClusterRoleBinding -export IoK8sApiRbacV1ClusterRoleBindingList -export IoK8sApiRbacV1ClusterRoleList -export IoK8sApiRbacV1PolicyRule -export IoK8sApiRbacV1Role -export IoK8sApiRbacV1RoleBinding -export IoK8sApiRbacV1RoleBindingList -export IoK8sApiRbacV1RoleList -export IoK8sApiRbacV1RoleRef -export IoK8sApiRbacV1Subject -export IoK8sApiRbacV1alpha1AggregationRule -export IoK8sApiRbacV1alpha1ClusterRole -export IoK8sApiRbacV1alpha1ClusterRoleBinding -export IoK8sApiRbacV1alpha1ClusterRoleBindingList -export IoK8sApiRbacV1alpha1ClusterRoleList -export IoK8sApiRbacV1alpha1PolicyRule -export IoK8sApiRbacV1alpha1Role -export IoK8sApiRbacV1alpha1RoleBinding -export IoK8sApiRbacV1alpha1RoleBindingList -export IoK8sApiRbacV1alpha1RoleList -export IoK8sApiRbacV1alpha1RoleRef -export IoK8sApiRbacV1alpha1Subject -export IoK8sApiRbacV1beta1AggregationRule -export IoK8sApiRbacV1beta1ClusterRole -export IoK8sApiRbacV1beta1ClusterRoleBinding -export IoK8sApiRbacV1beta1ClusterRoleBindingList -export IoK8sApiRbacV1beta1ClusterRoleList -export IoK8sApiRbacV1beta1PolicyRule -export IoK8sApiRbacV1beta1Role -export IoK8sApiRbacV1beta1RoleBinding -export IoK8sApiRbacV1beta1RoleBindingList -export IoK8sApiRbacV1beta1RoleList -export IoK8sApiRbacV1beta1RoleRef -export IoK8sApiRbacV1beta1Subject -export IoK8sApiSchedulingV1PriorityClass -export IoK8sApiSchedulingV1PriorityClassList -export IoK8sApiSchedulingV1alpha1PriorityClass -export IoK8sApiSchedulingV1alpha1PriorityClassList -export IoK8sApiSchedulingV1beta1PriorityClass -export IoK8sApiSchedulingV1beta1PriorityClassList -export IoK8sApiSettingsV1alpha1PodPreset -export IoK8sApiSettingsV1alpha1PodPresetList -export IoK8sApiSettingsV1alpha1PodPresetSpec -export IoK8sApiStorageV1CSINode -export IoK8sApiStorageV1CSINodeDriver -export IoK8sApiStorageV1CSINodeList -export IoK8sApiStorageV1CSINodeSpec -export IoK8sApiStorageV1StorageClass -export IoK8sApiStorageV1StorageClassList -export IoK8sApiStorageV1VolumeAttachment -export IoK8sApiStorageV1VolumeAttachmentList -export IoK8sApiStorageV1VolumeAttachmentSource -export IoK8sApiStorageV1VolumeAttachmentSpec -export IoK8sApiStorageV1VolumeAttachmentStatus -export IoK8sApiStorageV1VolumeError -export IoK8sApiStorageV1VolumeNodeResources -export IoK8sApiStorageV1alpha1VolumeAttachment -export IoK8sApiStorageV1alpha1VolumeAttachmentList -export IoK8sApiStorageV1alpha1VolumeAttachmentSource -export IoK8sApiStorageV1alpha1VolumeAttachmentSpec -export IoK8sApiStorageV1alpha1VolumeAttachmentStatus -export IoK8sApiStorageV1alpha1VolumeError -export IoK8sApiStorageV1beta1CSIDriver -export IoK8sApiStorageV1beta1CSIDriverList -export IoK8sApiStorageV1beta1CSIDriverSpec -export IoK8sApiStorageV1beta1CSINode -export IoK8sApiStorageV1beta1CSINodeDriver -export IoK8sApiStorageV1beta1CSINodeList -export IoK8sApiStorageV1beta1CSINodeSpec -export IoK8sApiStorageV1beta1StorageClass -export IoK8sApiStorageV1beta1StorageClassList -export IoK8sApiStorageV1beta1VolumeAttachment -export IoK8sApiStorageV1beta1VolumeAttachmentList -export IoK8sApiStorageV1beta1VolumeAttachmentSource -export IoK8sApiStorageV1beta1VolumeAttachmentSpec -export IoK8sApiStorageV1beta1VolumeAttachmentStatus -export IoK8sApiStorageV1beta1VolumeError -export IoK8sApiStorageV1beta1VolumeNodeResources -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference -export IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig -export IoK8sApimachineryPkgApisMetaV1APIGroup -export IoK8sApimachineryPkgApisMetaV1APIGroupList -export IoK8sApimachineryPkgApisMetaV1APIResource -export IoK8sApimachineryPkgApisMetaV1APIResourceList -export IoK8sApimachineryPkgApisMetaV1APIVersions -export IoK8sApimachineryPkgApisMetaV1DeleteOptions -export IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 -export IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery -export IoK8sApimachineryPkgApisMetaV1LabelSelector -export IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement -export IoK8sApimachineryPkgApisMetaV1ListMeta -export IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry -export IoK8sApimachineryPkgApisMetaV1ObjectMeta -export IoK8sApimachineryPkgApisMetaV1OwnerReference -export IoK8sApimachineryPkgApisMetaV1Preconditions -export IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR -export IoK8sApimachineryPkgApisMetaV1Status -export IoK8sApimachineryPkgApisMetaV1StatusCause -export IoK8sApimachineryPkgApisMetaV1StatusDetails -export IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 -export IoK8sApimachineryPkgApisMetaV1StatusV2 -export IoK8sApimachineryPkgApisMetaV1WatchEvent -export IoK8sApimachineryPkgVersionInfo -export IoK8sKubeAggregatorPkgApisApiregistrationV1APIService -export IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition -export IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList -export IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec -export IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus -export IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus -export IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference -export ShKarpenterV1alpha5Provisioner -export ShKarpenterV1alpha5ProvisionerList -export ShKarpenterV1alpha5ProvisionerSpec -export ShKarpenterV1alpha5ProvisionerSpecConsolidation -export ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration -export ShKarpenterV1alpha5ProvisionerSpecLimits -export ShKarpenterV1alpha5ProvisionerSpecProviderRef -export ShKarpenterV1alpha5ProvisionerSpecRequirementsInner -export ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner -export ShKarpenterV1alpha5ProvisionerStatus -export ShKarpenterV1alpha5ProvisionerStatusConditionsInner - -# export operations -export AdmissionregistrationApi -export AdmissionregistrationV1Api -export AdmissionregistrationV1beta1Api -export ApiextensionsApi -export ApiextensionsV1Api -export ApiextensionsV1beta1Api -export ApiregistrationApi -export ApiregistrationV1Api -export ApiregistrationV1beta1Api -export ApisApi -export AppsApi -export AppsV1Api -export AppsV1beta1Api -export AppsV1beta2Api -export AuditregistrationApi -export AuditregistrationV1alpha1Api -export AuthenticationApi -export AuthenticationV1Api -export AuthenticationV1beta1Api -export AuthorizationApi -export AuthorizationV1Api -export AuthorizationV1beta1Api -export AutoscalingApi -export AutoscalingV1Api -export AutoscalingV2beta1Api -export AutoscalingV2beta2Api -export BatchApi -export BatchV1Api -export BatchV1beta1Api -export BatchV2alpha1Api -export CertificatesApi -export CertificatesV1beta1Api -export CoordinationApi -export CoordinationV1Api -export CoordinationV1beta1Api -export CoreApi -export CoreV1Api -export CustomMetricsV1beta1Api -export DiscoveryApi -export DiscoveryV1beta1Api -export EventsApi -export EventsV1beta1Api -export ExtensionsApi -export ExtensionsV1beta1Api -export FlowcontrolApiserverApi -export FlowcontrolApiserverV1alpha1Api -export KarpenterShV1alpha5Api -export LogsApi -export MetricsV1beta1Api -export NetworkingApi -export NetworkingV1Api -export NetworkingV1beta1Api -export NodeApi -export NodeV1alpha1Api -export NodeV1beta1Api -export PolicyApi -export PolicyV1beta1Api -export RbacAuthorizationApi -export RbacAuthorizationV1Api -export RbacAuthorizationV1alpha1Api -export RbacAuthorizationV1beta1Api -export SchedulingApi -export SchedulingV1Api -export SchedulingV1alpha1Api -export SchedulingV1beta1Api -export SettingsApi -export SettingsV1alpha1Api -export StorageApi -export StorageV1Api -export StorageV1alpha1Api -export StorageV1beta1Api -export VersionApi - -end # module Kubernetes diff --git a/src/ApiImpl/api/apis/api_AdmissionregistrationApi.jl b/src/ApiImpl/api/apis/api_AdmissionregistrationApi.jl deleted file mode 100644 index 53ce18e7..00000000 --- a/src/ApiImpl/api/apis/api_AdmissionregistrationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AdmissionregistrationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AdmissionregistrationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AdmissionregistrationApi }) = "http://localhost" - -const _returntypes_get_admissionregistration_a_p_i_group_AdmissionregistrationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_admissionregistration_a_p_i_group(_api::AdmissionregistrationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_admissionregistration_a_p_i_group_AdmissionregistrationApi, "/apis/admissionregistration.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_admissionregistration_a_p_i_group(_api::AdmissionregistrationApi; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_admissionregistration_a_p_i_group(_api::AdmissionregistrationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_admissionregistration_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AdmissionregistrationV1Api.jl b/src/ApiImpl/api/apis/api_AdmissionregistrationV1Api.jl deleted file mode 100644 index e623c389..00000000 --- a/src/ApiImpl/api/apis/api_AdmissionregistrationV1Api.jl +++ /dev/null @@ -1,834 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AdmissionregistrationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AdmissionregistrationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AdmissionregistrationV1Api }) = "http://localhost" - -const _returntypes_create_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a MutatingWebhookConfiguration - -Params: -- body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function create_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1_mutating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1_mutating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ValidatingWebhookConfiguration - -Params: -- body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function create_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1_validating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1_validating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1_collection_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1_collection_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of MutatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1_collection_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1_collection_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ValidatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_collection_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_collection_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a MutatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_mutating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_mutating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ValidatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_validating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1_validating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_admissionregistration_v1_a_p_i_resources_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_admissionregistration_v1_a_p_i_resources(_api::AdmissionregistrationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_admissionregistration_v1_a_p_i_resources_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_admissionregistration_v1_a_p_i_resources(_api::AdmissionregistrationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_admissionregistration_v1_a_p_i_resources(_api::AdmissionregistrationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind MutatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, OpenAPI.Clients.ApiResponse -""" -function list_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ValidatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, OpenAPI.Clients.ApiResponse -""" -function list_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1_mutating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1_mutating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1_validating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1_validating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String, body::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String, body::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1_mutating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1_mutating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1_mutating_webhook_configuration_list_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1_mutating_webhook_configuration_list_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_mutating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1_validating_webhook_configuration_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1_validating_webhook_configuration(_api::AdmissionregistrationV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1_validating_webhook_configuration_list_AdmissionregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration_list(_api::AdmissionregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1_validating_webhook_configuration_list_AdmissionregistrationV1Api, "/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1_validating_webhook_configuration_list(_api::AdmissionregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1_validating_webhook_configuration_list(_api::AdmissionregistrationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1_validating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_admissionregistration_v1_mutating_webhook_configuration -export create_admissionregistration_v1_validating_webhook_configuration -export delete_admissionregistration_v1_collection_mutating_webhook_configuration -export delete_admissionregistration_v1_collection_validating_webhook_configuration -export delete_admissionregistration_v1_mutating_webhook_configuration -export delete_admissionregistration_v1_validating_webhook_configuration -export get_admissionregistration_v1_a_p_i_resources -export list_admissionregistration_v1_mutating_webhook_configuration -export list_admissionregistration_v1_validating_webhook_configuration -export patch_admissionregistration_v1_mutating_webhook_configuration -export patch_admissionregistration_v1_validating_webhook_configuration -export read_admissionregistration_v1_mutating_webhook_configuration -export read_admissionregistration_v1_validating_webhook_configuration -export replace_admissionregistration_v1_mutating_webhook_configuration -export replace_admissionregistration_v1_validating_webhook_configuration -export watch_admissionregistration_v1_mutating_webhook_configuration -export watch_admissionregistration_v1_mutating_webhook_configuration_list -export watch_admissionregistration_v1_validating_webhook_configuration -export watch_admissionregistration_v1_validating_webhook_configuration_list diff --git a/src/ApiImpl/api/apis/api_AdmissionregistrationV1beta1Api.jl b/src/ApiImpl/api/apis/api_AdmissionregistrationV1beta1Api.jl deleted file mode 100644 index bf417936..00000000 --- a/src/ApiImpl/api/apis/api_AdmissionregistrationV1beta1Api.jl +++ /dev/null @@ -1,834 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AdmissionregistrationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AdmissionregistrationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AdmissionregistrationV1beta1Api }) = "http://localhost" - -const _returntypes_create_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a MutatingWebhookConfiguration - -Params: -- body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function create_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1beta1_mutating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1beta1_mutating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ValidatingWebhookConfiguration - -Params: -- body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function create_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1beta1_validating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_admissionregistration_v1beta1_validating_webhook_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of MutatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1beta1_collection_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1beta1_collection_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ValidatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a MutatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ValidatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_admissionregistration_v1beta1_a_p_i_resources_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_admissionregistration_v1beta1_a_p_i_resources(_api::AdmissionregistrationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_admissionregistration_v1beta1_a_p_i_resources_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_admissionregistration_v1beta1_a_p_i_resources(_api::AdmissionregistrationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_admissionregistration_v1beta1_a_p_i_resources(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_admissionregistration_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind MutatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, OpenAPI.Clients.ApiResponse -""" -function list_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1beta1_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1beta1_mutating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ValidatingWebhookConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, OpenAPI.Clients.ApiResponse -""" -function list_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1beta1_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_admissionregistration_v1beta1_validating_webhook_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1beta1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_admissionregistration_v1beta1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified MutatingWebhookConfiguration - -Params: -- name::String (required) -- body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ValidatingWebhookConfiguration - -Params: -- name::String (required) -- body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1beta1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_admissionregistration_v1beta1_validating_webhook_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1beta1_mutating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1beta1_mutating_webhook_configuration_list_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1beta1_mutating_webhook_configuration_list_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1beta1_validating_webhook_configuration_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1beta1_validating_webhook_configuration(_api::AdmissionregistrationV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_admissionregistration_v1beta1_validating_webhook_configuration_list_AdmissionregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_admissionregistration_v1beta1_validating_webhook_configuration_list_AdmissionregistrationV1beta1Api, "/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api::AdmissionregistrationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_admissionregistration_v1beta1_mutating_webhook_configuration -export create_admissionregistration_v1beta1_validating_webhook_configuration -export delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration -export delete_admissionregistration_v1beta1_collection_validating_webhook_configuration -export delete_admissionregistration_v1beta1_mutating_webhook_configuration -export delete_admissionregistration_v1beta1_validating_webhook_configuration -export get_admissionregistration_v1beta1_a_p_i_resources -export list_admissionregistration_v1beta1_mutating_webhook_configuration -export list_admissionregistration_v1beta1_validating_webhook_configuration -export patch_admissionregistration_v1beta1_mutating_webhook_configuration -export patch_admissionregistration_v1beta1_validating_webhook_configuration -export read_admissionregistration_v1beta1_mutating_webhook_configuration -export read_admissionregistration_v1beta1_validating_webhook_configuration -export replace_admissionregistration_v1beta1_mutating_webhook_configuration -export replace_admissionregistration_v1beta1_validating_webhook_configuration -export watch_admissionregistration_v1beta1_mutating_webhook_configuration -export watch_admissionregistration_v1beta1_mutating_webhook_configuration_list -export watch_admissionregistration_v1beta1_validating_webhook_configuration -export watch_admissionregistration_v1beta1_validating_webhook_configuration_list diff --git a/src/ApiImpl/api/apis/api_ApiextensionsApi.jl b/src/ApiImpl/api/apis/api_ApiextensionsApi.jl deleted file mode 100644 index 75dda884..00000000 --- a/src/ApiImpl/api/apis/api_ApiextensionsApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiextensionsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiextensionsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiextensionsApi }) = "http://localhost" - -const _returntypes_get_apiextensions_a_p_i_group_ApiextensionsApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiextensions_a_p_i_group(_api::ApiextensionsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiextensions_a_p_i_group_ApiextensionsApi, "/apis/apiextensions.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_apiextensions_a_p_i_group(_api::ApiextensionsApi; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiextensions_a_p_i_group(_api::ApiextensionsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_apiextensions_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_ApiextensionsV1Api.jl b/src/ApiImpl/api/apis/api_ApiextensionsV1Api.jl deleted file mode 100644 index 9d6dd510..00000000 --- a/src/ApiImpl/api/apis/api_ApiextensionsV1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiextensionsV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiextensionsV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiextensionsV1Api }) = "http://localhost" - -const _returntypes_create_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CustomResourceDefinition - -Params: -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function create_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiextensions_v1_custom_resource_definition(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiextensions_v1_custom_resource_definition(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiextensions_v1_collection_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiextensions_v1_collection_custom_resource_definition(_api::ApiextensionsV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiextensions_v1_collection_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CustomResourceDefinition - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiextensions_v1_collection_custom_resource_definition(_api::ApiextensionsV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1_collection_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiextensions_v1_collection_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1_collection_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1_custom_resource_definition(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1_custom_resource_definition(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apiextensions_v1_a_p_i_resources_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiextensions_v1_a_p_i_resources(_api::ApiextensionsV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiextensions_v1_a_p_i_resources_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apiextensions_v1_a_p_i_resources(_api::ApiextensionsV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiextensions_v1_a_p_i_resources(_api::ApiextensionsV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CustomResourceDefinition - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, OpenAPI.Clients.ApiResponse -""" -function list_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiextensions_v1_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiextensions_v1_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function patch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function patch_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function read_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1_custom_resource_definition(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1_custom_resource_definition(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function read_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1_custom_resource_definition_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1_custom_resource_definition_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function replace_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiextensions_v1_custom_resource_definition_status_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function replace_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiextensions_v1_custom_resource_definition_status(_api::ApiextensionsV1Api, response_stream::Channel, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiextensions_v1_custom_resource_definition_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1_custom_resource_definition(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiextensions_v1_custom_resource_definition(_api::ApiextensionsV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1_custom_resource_definition(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiextensions_v1_custom_resource_definition_list_ApiextensionsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiextensions_v1_custom_resource_definition_list(_api::ApiextensionsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiextensions_v1_custom_resource_definition_list_ApiextensionsV1Api, "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiextensions_v1_custom_resource_definition_list(_api::ApiextensionsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1_custom_resource_definition_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiextensions_v1_custom_resource_definition_list(_api::ApiextensionsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1_custom_resource_definition_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apiextensions_v1_custom_resource_definition -export delete_apiextensions_v1_collection_custom_resource_definition -export delete_apiextensions_v1_custom_resource_definition -export get_apiextensions_v1_a_p_i_resources -export list_apiextensions_v1_custom_resource_definition -export patch_apiextensions_v1_custom_resource_definition -export patch_apiextensions_v1_custom_resource_definition_status -export read_apiextensions_v1_custom_resource_definition -export read_apiextensions_v1_custom_resource_definition_status -export replace_apiextensions_v1_custom_resource_definition -export replace_apiextensions_v1_custom_resource_definition_status -export watch_apiextensions_v1_custom_resource_definition -export watch_apiextensions_v1_custom_resource_definition_list diff --git a/src/ApiImpl/api/apis/api_ApiextensionsV1beta1Api.jl b/src/ApiImpl/api/apis/api_ApiextensionsV1beta1Api.jl deleted file mode 100644 index 332b13ac..00000000 --- a/src/ApiImpl/api/apis/api_ApiextensionsV1beta1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiextensionsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiextensionsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiextensionsV1beta1Api }) = "http://localhost" - -const _returntypes_create_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CustomResourceDefinition - -Params: -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function create_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiextensions_v1beta1_custom_resource_definition(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiextensions_v1beta1_custom_resource_definition(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiextensions_v1beta1_collection_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiextensions_v1beta1_collection_custom_resource_definition(_api::ApiextensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiextensions_v1beta1_collection_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CustomResourceDefinition - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiextensions_v1beta1_collection_custom_resource_definition(_api::ApiextensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1beta1_collection_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiextensions_v1beta1_collection_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1beta1_collection_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1beta1_custom_resource_definition(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiextensions_v1beta1_custom_resource_definition(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apiextensions_v1beta1_a_p_i_resources_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiextensions_v1beta1_a_p_i_resources(_api::ApiextensionsV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiextensions_v1beta1_a_p_i_resources_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apiextensions_v1beta1_a_p_i_resources(_api::ApiextensionsV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiextensions_v1beta1_a_p_i_resources(_api::ApiextensionsV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiextensions_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CustomResourceDefinition - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, OpenAPI.Clients.ApiResponse -""" -function list_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiextensions_v1beta1_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiextensions_v1beta1_custom_resource_definition(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function patch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function patch_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiextensions_v1beta1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function read_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1beta1_custom_resource_definition(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1beta1_custom_resource_definition(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function read_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1beta1_custom_resource_definition_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiextensions_v1beta1_custom_resource_definition_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function replace_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiextensions_v1beta1_custom_resource_definition_status_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CustomResourceDefinition - -Params: -- name::String (required) -- body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, OpenAPI.Clients.ApiResponse -""" -function replace_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiextensions_v1beta1_custom_resource_definition_status(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiextensions_v1beta1_custom_resource_definition_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiextensions_v1beta1_custom_resource_definition_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiextensions_v1beta1_custom_resource_definition(_api::ApiextensionsV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiextensions_v1beta1_custom_resource_definition_list_ApiextensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition_list(_api::ApiextensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiextensions_v1beta1_custom_resource_definition_list_ApiextensionsV1beta1Api, "/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiextensions_v1beta1_custom_resource_definition_list(_api::ApiextensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiextensions_v1beta1_custom_resource_definition_list(_api::ApiextensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiextensions_v1beta1_custom_resource_definition_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apiextensions_v1beta1_custom_resource_definition -export delete_apiextensions_v1beta1_collection_custom_resource_definition -export delete_apiextensions_v1beta1_custom_resource_definition -export get_apiextensions_v1beta1_a_p_i_resources -export list_apiextensions_v1beta1_custom_resource_definition -export patch_apiextensions_v1beta1_custom_resource_definition -export patch_apiextensions_v1beta1_custom_resource_definition_status -export read_apiextensions_v1beta1_custom_resource_definition -export read_apiextensions_v1beta1_custom_resource_definition_status -export replace_apiextensions_v1beta1_custom_resource_definition -export replace_apiextensions_v1beta1_custom_resource_definition_status -export watch_apiextensions_v1beta1_custom_resource_definition -export watch_apiextensions_v1beta1_custom_resource_definition_list diff --git a/src/ApiImpl/api/apis/api_ApiregistrationApi.jl b/src/ApiImpl/api/apis/api_ApiregistrationApi.jl deleted file mode 100644 index 9b8c3ac4..00000000 --- a/src/ApiImpl/api/apis/api_ApiregistrationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiregistrationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiregistrationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiregistrationApi }) = "http://localhost" - -const _returntypes_get_apiregistration_a_p_i_group_ApiregistrationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiregistration_a_p_i_group(_api::ApiregistrationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiregistration_a_p_i_group_ApiregistrationApi, "/apis/apiregistration.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_apiregistration_a_p_i_group(_api::ApiregistrationApi; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiregistration_a_p_i_group(_api::ApiregistrationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_apiregistration_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_ApiregistrationV1Api.jl b/src/ApiImpl/api/apis/api_ApiregistrationV1Api.jl deleted file mode 100644 index 57ce6f3c..00000000 --- a/src/ApiImpl/api/apis/api_ApiregistrationV1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiregistrationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiregistrationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiregistrationV1Api }) = "http://localhost" - -const _returntypes_create_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an APIService - -Params: -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function create_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiregistration_v1_a_p_i_service(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiregistration_v1_a_p_i_service(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an APIService - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1_a_p_i_service(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1_a_p_i_service(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiregistration_v1_collection_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiregistration_v1_collection_a_p_i_service(_api::ApiregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiregistration_v1_collection_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of APIService - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiregistration_v1_collection_a_p_i_service(_api::ApiregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1_collection_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiregistration_v1_collection_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1_collection_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apiregistration_v1_a_p_i_resources_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiregistration_v1_a_p_i_resources(_api::ApiregistrationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiregistration_v1_a_p_i_resources_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apiregistration_v1_a_p_i_resources(_api::ApiregistrationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiregistration_v1_a_p_i_resources(_api::ApiregistrationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind APIService - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, OpenAPI.Clients.ApiResponse -""" -function list_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiregistration_v1_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiregistration_v1_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified APIService - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function patch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified APIService - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function patch_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified APIService - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function read_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1_a_p_i_service(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1_a_p_i_service(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified APIService - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function read_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1_a_p_i_service_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1_a_p_i_service_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified APIService - -Params: -- name::String (required) -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function replace_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiregistration_v1_a_p_i_service_status_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified APIService - -Params: -- name::String (required) -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, OpenAPI.Clients.ApiResponse -""" -function replace_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiregistration_v1_a_p_i_service_status(_api::ApiregistrationV1Api, response_stream::Channel, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiregistration_v1_a_p_i_service_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiregistration_v1_a_p_i_service_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1_a_p_i_service(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiregistration_v1_a_p_i_service(_api::ApiregistrationV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1_a_p_i_service(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiregistration_v1_a_p_i_service_list_ApiregistrationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiregistration_v1_a_p_i_service_list(_api::ApiregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiregistration_v1_a_p_i_service_list_ApiregistrationV1Api, "/apis/apiregistration.k8s.io/v1/watch/apiservices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiregistration_v1_a_p_i_service_list(_api::ApiregistrationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1_a_p_i_service_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiregistration_v1_a_p_i_service_list(_api::ApiregistrationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1_a_p_i_service_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apiregistration_v1_a_p_i_service -export delete_apiregistration_v1_a_p_i_service -export delete_apiregistration_v1_collection_a_p_i_service -export get_apiregistration_v1_a_p_i_resources -export list_apiregistration_v1_a_p_i_service -export patch_apiregistration_v1_a_p_i_service -export patch_apiregistration_v1_a_p_i_service_status -export read_apiregistration_v1_a_p_i_service -export read_apiregistration_v1_a_p_i_service_status -export replace_apiregistration_v1_a_p_i_service -export replace_apiregistration_v1_a_p_i_service_status -export watch_apiregistration_v1_a_p_i_service -export watch_apiregistration_v1_a_p_i_service_list diff --git a/src/ApiImpl/api/apis/api_ApiregistrationV1beta1Api.jl b/src/ApiImpl/api/apis/api_ApiregistrationV1beta1Api.jl deleted file mode 100644 index 96e47ab7..00000000 --- a/src/ApiImpl/api/apis/api_ApiregistrationV1beta1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApiregistrationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApiregistrationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApiregistrationV1beta1Api }) = "http://localhost" - -const _returntypes_create_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an APIService - -Params: -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function create_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiregistration_v1beta1_a_p_i_service(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apiregistration_v1beta1_a_p_i_service(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an APIService - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1beta1_a_p_i_service(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1beta1_a_p_i_service(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apiregistration_v1beta1_collection_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apiregistration_v1beta1_collection_a_p_i_service(_api::ApiregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apiregistration_v1beta1_collection_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of APIService - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apiregistration_v1beta1_collection_a_p_i_service(_api::ApiregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1beta1_collection_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apiregistration_v1beta1_collection_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apiregistration_v1beta1_collection_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apiregistration_v1beta1_a_p_i_resources_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apiregistration_v1beta1_a_p_i_resources(_api::ApiregistrationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apiregistration_v1beta1_a_p_i_resources_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apiregistration_v1beta1_a_p_i_resources(_api::ApiregistrationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apiregistration_v1beta1_a_p_i_resources(_api::ApiregistrationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apiregistration_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind APIService - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, OpenAPI.Clients.ApiResponse -""" -function list_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiregistration_v1beta1_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apiregistration_v1beta1_a_p_i_service(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified APIService - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function patch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1beta1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1beta1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified APIService - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function patch_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1beta1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apiregistration_v1beta1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified APIService - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function read_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1beta1_a_p_i_service(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1beta1_a_p_i_service(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified APIService - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function read_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1beta1_a_p_i_service_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apiregistration_v1beta1_a_p_i_service_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified APIService - -Params: -- name::String (required) -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function replace_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1beta1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1beta1_a_p_i_service(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apiregistration_v1beta1_a_p_i_service_status_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/apiservices/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified APIService - -Params: -- name::String (required) -- body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, OpenAPI.Clients.ApiResponse -""" -function replace_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1beta1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apiregistration_v1beta1_a_p_i_service_status(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apiregistration_v1beta1_a_p_i_service_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiregistration_v1beta1_a_p_i_service_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/watch/apiservices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1beta1_a_p_i_service(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiregistration_v1beta1_a_p_i_service(_api::ApiregistrationV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1beta1_a_p_i_service(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apiregistration_v1beta1_a_p_i_service_list_ApiregistrationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apiregistration_v1beta1_a_p_i_service_list(_api::ApiregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apiregistration_v1beta1_a_p_i_service_list_ApiregistrationV1beta1Api, "/apis/apiregistration.k8s.io/v1beta1/watch/apiservices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apiregistration_v1beta1_a_p_i_service_list(_api::ApiregistrationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1beta1_a_p_i_service_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apiregistration_v1beta1_a_p_i_service_list(_api::ApiregistrationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apiregistration_v1beta1_a_p_i_service_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apiregistration_v1beta1_a_p_i_service -export delete_apiregistration_v1beta1_a_p_i_service -export delete_apiregistration_v1beta1_collection_a_p_i_service -export get_apiregistration_v1beta1_a_p_i_resources -export list_apiregistration_v1beta1_a_p_i_service -export patch_apiregistration_v1beta1_a_p_i_service -export patch_apiregistration_v1beta1_a_p_i_service_status -export read_apiregistration_v1beta1_a_p_i_service -export read_apiregistration_v1beta1_a_p_i_service_status -export replace_apiregistration_v1beta1_a_p_i_service -export replace_apiregistration_v1beta1_a_p_i_service_status -export watch_apiregistration_v1beta1_a_p_i_service -export watch_apiregistration_v1beta1_a_p_i_service_list diff --git a/src/ApiImpl/api/apis/api_ApisApi.jl b/src/ApiImpl/api/apis/api_ApisApi.jl deleted file mode 100644 index 7117276d..00000000 --- a/src/ApiImpl/api/apis/api_ApisApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ApisApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ApisApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ApisApi }) = "http://localhost" - -const _returntypes_get_a_p_i_versions_ApisApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroupList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_a_p_i_versions(_api::ApisApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_a_p_i_versions_ApisApi, "/apis/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available API versions - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroupList, OpenAPI.Clients.ApiResponse -""" -function get_a_p_i_versions(_api::ApisApi; _mediaType=nothing) - _ctx = _oacinternal_get_a_p_i_versions(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_a_p_i_versions(_api::ApisApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_a_p_i_versions(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_a_p_i_versions diff --git a/src/ApiImpl/api/apis/api_AppsApi.jl b/src/ApiImpl/api/apis/api_AppsApi.jl deleted file mode 100644 index 03f44e04..00000000 --- a/src/ApiImpl/api/apis/api_AppsApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AppsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AppsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AppsApi }) = "http://localhost" - -const _returntypes_get_apps_a_p_i_group_AppsApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apps_a_p_i_group(_api::AppsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apps_a_p_i_group_AppsApi, "/apis/apps/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_apps_a_p_i_group(_api::AppsApi; _mediaType=nothing) - _ctx = _oacinternal_get_apps_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apps_a_p_i_group(_api::AppsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apps_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_apps_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AppsV1Api.jl b/src/ApiImpl/api/apis/api_AppsV1Api.jl deleted file mode 100644 index 8ae228a6..00000000 --- a/src/ApiImpl/api/apis/api_AppsV1Api.jl +++ /dev/null @@ -1,3408 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AppsV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AppsV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AppsV1Api }) = "http://localhost" - -const _returntypes_create_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1_namespaced_controller_revision(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ControllerRevision - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1_namespaced_controller_revision(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1_namespaced_daemon_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a DaemonSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1_namespaced_daemon_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1_namespaced_deployment(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Deployment - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1_namespaced_deployment(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1_namespaced_replica_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ReplicaSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1_namespaced_replica_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1_namespaced_stateful_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a StatefulSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1_namespaced_stateful_set(_api::AppsV1Api, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_collection_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_collection_namespaced_controller_revision(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_collection_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_collection_namespaced_controller_revision(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_collection_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_collection_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_collection_namespaced_daemon_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_collection_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_collection_namespaced_daemon_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_collection_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_collection_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_collection_namespaced_deployment(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_collection_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_collection_namespaced_deployment(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_collection_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_collection_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_collection_namespaced_replica_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_collection_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_collection_namespaced_replica_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_collection_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_collection_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_collection_namespaced_stateful_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_collection_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_collection_namespaced_stateful_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_collection_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apps_v1_a_p_i_resources_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apps_v1_a_p_i_resources(_api::AppsV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apps_v1_a_p_i_resources_AppsV1Api, "/apis/apps/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apps_v1_a_p_i_resources(_api::AppsV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apps_v1_a_p_i_resources(_api::AppsV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_controller_revision_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_controller_revision_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_controller_revision_for_all_namespaces_AppsV1Api, "/apis/apps/v1/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_controller_revision_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_controller_revision_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_daemon_set_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_daemon_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_daemon_set_for_all_namespaces_AppsV1Api, "/apis/apps/v1/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_daemon_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_daemon_set_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_deployment_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_deployment_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_deployment_for_all_namespaces_AppsV1Api, "/apis/apps/v1/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_deployment_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_deployment_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_namespaced_controller_revision(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_namespaced_controller_revision(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_namespaced_daemon_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_namespaced_daemon_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_namespaced_deployment(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_namespaced_deployment(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_namespaced_replica_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_namespaced_replica_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_namespaced_stateful_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_namespaced_stateful_set(_api::AppsV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_replica_set_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_replica_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_replica_set_for_all_namespaces_AppsV1Api, "/apis/apps/v1/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_replica_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_replica_set_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1_stateful_set_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1_stateful_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1_stateful_set_for_all_namespaces_AppsV1Api, "/apis/apps/v1/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1_stateful_set_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1_stateful_set_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_daemon_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_daemon_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_deployment_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_deployment_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_deployment_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_deployment_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_deployment_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_replica_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_replica_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_replica_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_replica_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_stateful_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_stateful_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1_namespaced_stateful_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1_namespaced_stateful_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_daemon_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_daemon_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_deployment_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_deployment_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_deployment_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_deployment_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_deployment_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_replica_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_replica_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_replica_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_replica_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_stateful_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_stateful_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1_namespaced_stateful_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1_namespaced_stateful_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_daemon_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_daemon_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_daemon_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_deployment_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_deployment_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_deployment_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_deployment_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_deployment_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_deployment_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_deployment_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_replica_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_replica_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_replica_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_replica_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_replica_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_replica_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_stateful_set_scale_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_stateful_set_scale_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_stateful_set_scale(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1_namespaced_stateful_set_status_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1_namespaced_stateful_set_status_AppsV1Api, "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1_namespaced_stateful_set_status(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_controller_revision_list_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_controller_revision_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_controller_revision_list_for_all_namespaces_AppsV1Api, "/apis/apps/v1/watch/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_controller_revision_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_controller_revision_list_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_daemon_set_list_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_daemon_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_daemon_set_list_for_all_namespaces_AppsV1Api, "/apis/apps/v1/watch/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_daemon_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_daemon_set_list_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_deployment_list_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_deployment_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_deployment_list_for_all_namespaces_AppsV1Api, "/apis/apps/v1/watch/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_deployment_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_deployment_list_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_controller_revision_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_controller_revision_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_controller_revision(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_controller_revision_list_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_controller_revision_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_controller_revision_list_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_controller_revision_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_controller_revision_list(_api::AppsV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_daemon_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_daemon_set_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_daemon_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_daemon_set_list_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_daemon_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_daemon_set_list_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_daemon_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_daemon_set_list(_api::AppsV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_deployment_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_deployment_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_deployment(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_deployment(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_deployment_list_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_deployment_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_deployment_list_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_deployment_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_deployment_list(_api::AppsV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_replica_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_replica_set_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_replica_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_replica_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_replica_set_list_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_replica_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_replica_set_list_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_replica_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_replica_set_list(_api::AppsV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_stateful_set_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_stateful_set_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_stateful_set(_api::AppsV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_namespaced_stateful_set_list_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_namespaced_stateful_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_namespaced_stateful_set_list_AppsV1Api, "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_namespaced_stateful_set_list(_api::AppsV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_namespaced_stateful_set_list(_api::AppsV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_replica_set_list_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_replica_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_replica_set_list_for_all_namespaces_AppsV1Api, "/apis/apps/v1/watch/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_replica_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_replica_set_list_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1_stateful_set_list_for_all_namespaces_AppsV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1_stateful_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1_stateful_set_list_for_all_namespaces_AppsV1Api, "/apis/apps/v1/watch/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1_stateful_set_list_for_all_namespaces(_api::AppsV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1_stateful_set_list_for_all_namespaces(_api::AppsV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apps_v1_namespaced_controller_revision -export create_apps_v1_namespaced_daemon_set -export create_apps_v1_namespaced_deployment -export create_apps_v1_namespaced_replica_set -export create_apps_v1_namespaced_stateful_set -export delete_apps_v1_collection_namespaced_controller_revision -export delete_apps_v1_collection_namespaced_daemon_set -export delete_apps_v1_collection_namespaced_deployment -export delete_apps_v1_collection_namespaced_replica_set -export delete_apps_v1_collection_namespaced_stateful_set -export delete_apps_v1_namespaced_controller_revision -export delete_apps_v1_namespaced_daemon_set -export delete_apps_v1_namespaced_deployment -export delete_apps_v1_namespaced_replica_set -export delete_apps_v1_namespaced_stateful_set -export get_apps_v1_a_p_i_resources -export list_apps_v1_controller_revision_for_all_namespaces -export list_apps_v1_daemon_set_for_all_namespaces -export list_apps_v1_deployment_for_all_namespaces -export list_apps_v1_namespaced_controller_revision -export list_apps_v1_namespaced_daemon_set -export list_apps_v1_namespaced_deployment -export list_apps_v1_namespaced_replica_set -export list_apps_v1_namespaced_stateful_set -export list_apps_v1_replica_set_for_all_namespaces -export list_apps_v1_stateful_set_for_all_namespaces -export patch_apps_v1_namespaced_controller_revision -export patch_apps_v1_namespaced_daemon_set -export patch_apps_v1_namespaced_daemon_set_status -export patch_apps_v1_namespaced_deployment -export patch_apps_v1_namespaced_deployment_scale -export patch_apps_v1_namespaced_deployment_status -export patch_apps_v1_namespaced_replica_set -export patch_apps_v1_namespaced_replica_set_scale -export patch_apps_v1_namespaced_replica_set_status -export patch_apps_v1_namespaced_stateful_set -export patch_apps_v1_namespaced_stateful_set_scale -export patch_apps_v1_namespaced_stateful_set_status -export read_apps_v1_namespaced_controller_revision -export read_apps_v1_namespaced_daemon_set -export read_apps_v1_namespaced_daemon_set_status -export read_apps_v1_namespaced_deployment -export read_apps_v1_namespaced_deployment_scale -export read_apps_v1_namespaced_deployment_status -export read_apps_v1_namespaced_replica_set -export read_apps_v1_namespaced_replica_set_scale -export read_apps_v1_namespaced_replica_set_status -export read_apps_v1_namespaced_stateful_set -export read_apps_v1_namespaced_stateful_set_scale -export read_apps_v1_namespaced_stateful_set_status -export replace_apps_v1_namespaced_controller_revision -export replace_apps_v1_namespaced_daemon_set -export replace_apps_v1_namespaced_daemon_set_status -export replace_apps_v1_namespaced_deployment -export replace_apps_v1_namespaced_deployment_scale -export replace_apps_v1_namespaced_deployment_status -export replace_apps_v1_namespaced_replica_set -export replace_apps_v1_namespaced_replica_set_scale -export replace_apps_v1_namespaced_replica_set_status -export replace_apps_v1_namespaced_stateful_set -export replace_apps_v1_namespaced_stateful_set_scale -export replace_apps_v1_namespaced_stateful_set_status -export watch_apps_v1_controller_revision_list_for_all_namespaces -export watch_apps_v1_daemon_set_list_for_all_namespaces -export watch_apps_v1_deployment_list_for_all_namespaces -export watch_apps_v1_namespaced_controller_revision -export watch_apps_v1_namespaced_controller_revision_list -export watch_apps_v1_namespaced_daemon_set -export watch_apps_v1_namespaced_daemon_set_list -export watch_apps_v1_namespaced_deployment -export watch_apps_v1_namespaced_deployment_list -export watch_apps_v1_namespaced_replica_set -export watch_apps_v1_namespaced_replica_set_list -export watch_apps_v1_namespaced_stateful_set -export watch_apps_v1_namespaced_stateful_set_list -export watch_apps_v1_replica_set_list_for_all_namespaces -export watch_apps_v1_stateful_set_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_AppsV1beta1Api.jl b/src/ApiImpl/api/apis/api_AppsV1beta1Api.jl deleted file mode 100644 index f04928a7..00000000 --- a/src/ApiImpl/api/apis/api_AppsV1beta1Api.jl +++ /dev/null @@ -1,2080 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AppsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AppsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AppsV1beta1Api }) = "http://localhost" - -const _returntypes_create_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ControllerRevision - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta1ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Deployment - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta1_namespaced_deployment_rollback_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta1_namespaced_deployment_rollback(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta1_namespaced_deployment_rollback_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/rollback", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create rollback of a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1DeploymentRollback (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta1_namespaced_deployment_rollback(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_deployment_rollback(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta1_namespaced_deployment_rollback(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_deployment_rollback(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a StatefulSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta1_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_collection_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_collection_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_collection_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_collection_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_collection_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_collection_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_collection_namespaced_deployment(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_collection_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_collection_namespaced_deployment(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_collection_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_collection_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_collection_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_collection_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_collection_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_collection_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apps_v1beta1_a_p_i_resources_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apps_v1beta1_a_p_i_resources(_api::AppsV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apps_v1beta1_a_p_i_resources_AppsV1beta1Api, "/apis/apps/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apps_v1beta1_a_p_i_resources(_api::AppsV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apps_v1beta1_a_p_i_resources(_api::AppsV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_controller_revision_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_controller_revision_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_controller_revision_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_controller_revision_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_controller_revision_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_deployment_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_deployment_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_deployment_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_deployment_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_deployment_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta1_stateful_set_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta1_stateful_set_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta1_stateful_set_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta1StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta1_stateful_set_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta1_stateful_set_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta1_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_deployment_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_deployment_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_deployment_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_deployment_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_stateful_set_scale_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_stateful_set_scale(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta1StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta1_namespaced_stateful_set_status_AppsV1beta1Api, "/apis/apps/v1beta1/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta1StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta1StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta1_namespaced_stateful_set_status(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta1StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta1_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_controller_revision_list_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_controller_revision_list_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/watch/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_deployment_list_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_deployment_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_deployment_list_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/watch/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_deployment_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_deployment_list_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_controller_revision_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_controller_revision(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_controller_revision_list_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_controller_revision_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_controller_revision_list_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_controller_revision_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_controller_revision_list(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_deployment_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_deployment_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_deployment(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_deployment_list_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_deployment_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_deployment_list_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_deployment_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_deployment_list(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_stateful_set_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_stateful_set(_api::AppsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_namespaced_stateful_set_list_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_namespaced_stateful_set_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_namespaced_stateful_set_list_AppsV1beta1Api, "/apis/apps/v1beta1/watch/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_namespaced_stateful_set_list(_api::AppsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_namespaced_stateful_set_list(_api::AppsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta1_stateful_set_list_for_all_namespaces_AppsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta1_stateful_set_list_for_all_namespaces_AppsV1beta1Api, "/apis/apps/v1beta1/watch/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api::AppsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api::AppsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apps_v1beta1_namespaced_controller_revision -export create_apps_v1beta1_namespaced_deployment -export create_apps_v1beta1_namespaced_deployment_rollback -export create_apps_v1beta1_namespaced_stateful_set -export delete_apps_v1beta1_collection_namespaced_controller_revision -export delete_apps_v1beta1_collection_namespaced_deployment -export delete_apps_v1beta1_collection_namespaced_stateful_set -export delete_apps_v1beta1_namespaced_controller_revision -export delete_apps_v1beta1_namespaced_deployment -export delete_apps_v1beta1_namespaced_stateful_set -export get_apps_v1beta1_a_p_i_resources -export list_apps_v1beta1_controller_revision_for_all_namespaces -export list_apps_v1beta1_deployment_for_all_namespaces -export list_apps_v1beta1_namespaced_controller_revision -export list_apps_v1beta1_namespaced_deployment -export list_apps_v1beta1_namespaced_stateful_set -export list_apps_v1beta1_stateful_set_for_all_namespaces -export patch_apps_v1beta1_namespaced_controller_revision -export patch_apps_v1beta1_namespaced_deployment -export patch_apps_v1beta1_namespaced_deployment_scale -export patch_apps_v1beta1_namespaced_deployment_status -export patch_apps_v1beta1_namespaced_stateful_set -export patch_apps_v1beta1_namespaced_stateful_set_scale -export patch_apps_v1beta1_namespaced_stateful_set_status -export read_apps_v1beta1_namespaced_controller_revision -export read_apps_v1beta1_namespaced_deployment -export read_apps_v1beta1_namespaced_deployment_scale -export read_apps_v1beta1_namespaced_deployment_status -export read_apps_v1beta1_namespaced_stateful_set -export read_apps_v1beta1_namespaced_stateful_set_scale -export read_apps_v1beta1_namespaced_stateful_set_status -export replace_apps_v1beta1_namespaced_controller_revision -export replace_apps_v1beta1_namespaced_deployment -export replace_apps_v1beta1_namespaced_deployment_scale -export replace_apps_v1beta1_namespaced_deployment_status -export replace_apps_v1beta1_namespaced_stateful_set -export replace_apps_v1beta1_namespaced_stateful_set_scale -export replace_apps_v1beta1_namespaced_stateful_set_status -export watch_apps_v1beta1_controller_revision_list_for_all_namespaces -export watch_apps_v1beta1_deployment_list_for_all_namespaces -export watch_apps_v1beta1_namespaced_controller_revision -export watch_apps_v1beta1_namespaced_controller_revision_list -export watch_apps_v1beta1_namespaced_deployment -export watch_apps_v1beta1_namespaced_deployment_list -export watch_apps_v1beta1_namespaced_stateful_set -export watch_apps_v1beta1_namespaced_stateful_set_list -export watch_apps_v1beta1_stateful_set_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_AppsV1beta2Api.jl b/src/ApiImpl/api/apis/api_AppsV1beta2Api.jl deleted file mode 100644 index 9ee79ec0..00000000 --- a/src/ApiImpl/api/apis/api_AppsV1beta2Api.jl +++ /dev/null @@ -1,3408 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AppsV1beta2Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AppsV1beta2Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AppsV1beta2Api }) = "http://localhost" - -const _returntypes_create_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ControllerRevision - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta2ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_controller_revision(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a DaemonSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta2DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Deployment - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ReplicaSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta2ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a StatefulSet - -Params: -- namespace::String (required) -- body::IoK8sApiAppsV1beta2StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function create_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_apps_v1beta2_namespaced_stateful_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_collection_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_collection_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_collection_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_collection_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_collection_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_collection_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_collection_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_collection_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_collection_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_collection_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_collection_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_collection_namespaced_deployment(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_collection_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_collection_namespaced_deployment(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_collection_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_collection_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_collection_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_collection_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_collection_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_collection_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_collection_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_collection_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_collection_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_collection_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_collection_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_collection_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_apps_v1beta2_a_p_i_resources_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_apps_v1beta2_a_p_i_resources(_api::AppsV1beta2Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_apps_v1beta2_a_p_i_resources_AppsV1beta2Api, "/apis/apps/v1beta2/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_apps_v1beta2_a_p_i_resources(_api::AppsV1beta2Api; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1beta2_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_apps_v1beta2_a_p_i_resources(_api::AppsV1beta2Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_apps_v1beta2_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_controller_revision_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_controller_revision_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_controller_revision_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_controller_revision_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_controller_revision_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_controller_revision_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_daemon_set_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_daemon_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_daemon_set_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_daemon_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_daemon_set_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_deployment_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_deployment_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_deployment_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_deployment_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_deployment_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevisionList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ControllerRevision - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2ControllerRevisionList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_controller_revision(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_namespaced_stateful_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_replica_set_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_replica_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_replica_set_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_replica_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_replica_set_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_apps_v1beta2_stateful_set_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_apps_v1beta2_stateful_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_apps_v1beta2_stateful_set_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StatefulSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAppsV1beta2StatefulSetList, OpenAPI.Clients.ApiResponse -""" -function list_apps_v1beta2_stateful_set_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_apps_v1beta2_stateful_set_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_apps_v1beta2_stateful_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function patch_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta2ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function read_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ControllerRevision, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ControllerRevision - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2ControllerRevision (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2ControllerRevision, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2ControllerRevision; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_controller_revision(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_daemon_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_daemon_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_deployment_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_deployment_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_deployment_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_deployment_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_replica_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_replica_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_replica_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_replica_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_stateful_set_scale_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2Scale, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_stateful_set_scale(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAppsV1beta2StatefulSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_apps_v1beta2_namespaced_stateful_set_status_AppsV1beta2Api, "/apis/apps/v1beta2/namespaces/{namespace}/statefulsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified StatefulSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAppsV1beta2StatefulSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAppsV1beta2StatefulSet, OpenAPI.Clients.ApiResponse -""" -function replace_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_apps_v1beta2_namespaced_stateful_set_status(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAppsV1beta2StatefulSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_apps_v1beta2_namespaced_stateful_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_controller_revision_list_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_controller_revision_list_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/watch/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_daemon_set_list_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_daemon_set_list_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/watch/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_deployment_list_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_deployment_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_deployment_list_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/watch/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_deployment_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_deployment_list_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_controller_revision_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/controllerrevisions/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_controller_revision(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_controller_revision(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_controller_revision_list_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_controller_revision_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_controller_revision_list_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/controllerrevisions", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_controller_revision_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_controller_revision_list(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_controller_revision_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_daemon_set_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_daemon_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_daemon_set_list_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_daemon_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_daemon_set_list_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_daemon_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_daemon_set_list(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_deployment_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_deployment_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_deployment(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_deployment_list_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_deployment_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_deployment_list_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_deployment_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_deployment_list(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_replica_set_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_replica_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_replica_set_list_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_replica_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_replica_set_list_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_replica_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_replica_set_list(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_stateful_set_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/statefulsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_stateful_set(_api::AppsV1beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_stateful_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_namespaced_stateful_set_list_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_namespaced_stateful_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_namespaced_stateful_set_list_AppsV1beta2Api, "/apis/apps/v1beta2/watch/namespaces/{namespace}/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_namespaced_stateful_set_list(_api::AppsV1beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_namespaced_stateful_set_list(_api::AppsV1beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_namespaced_stateful_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_replica_set_list_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_replica_set_list_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/watch/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_apps_v1beta2_stateful_set_list_for_all_namespaces_AppsV1beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_apps_v1beta2_stateful_set_list_for_all_namespaces_AppsV1beta2Api, "/apis/apps/v1beta2/watch/statefulsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api::AppsV1beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api::AppsV1beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_apps_v1beta2_namespaced_controller_revision -export create_apps_v1beta2_namespaced_daemon_set -export create_apps_v1beta2_namespaced_deployment -export create_apps_v1beta2_namespaced_replica_set -export create_apps_v1beta2_namespaced_stateful_set -export delete_apps_v1beta2_collection_namespaced_controller_revision -export delete_apps_v1beta2_collection_namespaced_daemon_set -export delete_apps_v1beta2_collection_namespaced_deployment -export delete_apps_v1beta2_collection_namespaced_replica_set -export delete_apps_v1beta2_collection_namespaced_stateful_set -export delete_apps_v1beta2_namespaced_controller_revision -export delete_apps_v1beta2_namespaced_daemon_set -export delete_apps_v1beta2_namespaced_deployment -export delete_apps_v1beta2_namespaced_replica_set -export delete_apps_v1beta2_namespaced_stateful_set -export get_apps_v1beta2_a_p_i_resources -export list_apps_v1beta2_controller_revision_for_all_namespaces -export list_apps_v1beta2_daemon_set_for_all_namespaces -export list_apps_v1beta2_deployment_for_all_namespaces -export list_apps_v1beta2_namespaced_controller_revision -export list_apps_v1beta2_namespaced_daemon_set -export list_apps_v1beta2_namespaced_deployment -export list_apps_v1beta2_namespaced_replica_set -export list_apps_v1beta2_namespaced_stateful_set -export list_apps_v1beta2_replica_set_for_all_namespaces -export list_apps_v1beta2_stateful_set_for_all_namespaces -export patch_apps_v1beta2_namespaced_controller_revision -export patch_apps_v1beta2_namespaced_daemon_set -export patch_apps_v1beta2_namespaced_daemon_set_status -export patch_apps_v1beta2_namespaced_deployment -export patch_apps_v1beta2_namespaced_deployment_scale -export patch_apps_v1beta2_namespaced_deployment_status -export patch_apps_v1beta2_namespaced_replica_set -export patch_apps_v1beta2_namespaced_replica_set_scale -export patch_apps_v1beta2_namespaced_replica_set_status -export patch_apps_v1beta2_namespaced_stateful_set -export patch_apps_v1beta2_namespaced_stateful_set_scale -export patch_apps_v1beta2_namespaced_stateful_set_status -export read_apps_v1beta2_namespaced_controller_revision -export read_apps_v1beta2_namespaced_daemon_set -export read_apps_v1beta2_namespaced_daemon_set_status -export read_apps_v1beta2_namespaced_deployment -export read_apps_v1beta2_namespaced_deployment_scale -export read_apps_v1beta2_namespaced_deployment_status -export read_apps_v1beta2_namespaced_replica_set -export read_apps_v1beta2_namespaced_replica_set_scale -export read_apps_v1beta2_namespaced_replica_set_status -export read_apps_v1beta2_namespaced_stateful_set -export read_apps_v1beta2_namespaced_stateful_set_scale -export read_apps_v1beta2_namespaced_stateful_set_status -export replace_apps_v1beta2_namespaced_controller_revision -export replace_apps_v1beta2_namespaced_daemon_set -export replace_apps_v1beta2_namespaced_daemon_set_status -export replace_apps_v1beta2_namespaced_deployment -export replace_apps_v1beta2_namespaced_deployment_scale -export replace_apps_v1beta2_namespaced_deployment_status -export replace_apps_v1beta2_namespaced_replica_set -export replace_apps_v1beta2_namespaced_replica_set_scale -export replace_apps_v1beta2_namespaced_replica_set_status -export replace_apps_v1beta2_namespaced_stateful_set -export replace_apps_v1beta2_namespaced_stateful_set_scale -export replace_apps_v1beta2_namespaced_stateful_set_status -export watch_apps_v1beta2_controller_revision_list_for_all_namespaces -export watch_apps_v1beta2_daemon_set_list_for_all_namespaces -export watch_apps_v1beta2_deployment_list_for_all_namespaces -export watch_apps_v1beta2_namespaced_controller_revision -export watch_apps_v1beta2_namespaced_controller_revision_list -export watch_apps_v1beta2_namespaced_daemon_set -export watch_apps_v1beta2_namespaced_daemon_set_list -export watch_apps_v1beta2_namespaced_deployment -export watch_apps_v1beta2_namespaced_deployment_list -export watch_apps_v1beta2_namespaced_replica_set -export watch_apps_v1beta2_namespaced_replica_set_list -export watch_apps_v1beta2_namespaced_stateful_set -export watch_apps_v1beta2_namespaced_stateful_set_list -export watch_apps_v1beta2_replica_set_list_for_all_namespaces -export watch_apps_v1beta2_stateful_set_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_AuditregistrationApi.jl b/src/ApiImpl/api/apis/api_AuditregistrationApi.jl deleted file mode 100644 index 0b410cb0..00000000 --- a/src/ApiImpl/api/apis/api_AuditregistrationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuditregistrationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuditregistrationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuditregistrationApi }) = "http://localhost" - -const _returntypes_get_auditregistration_a_p_i_group_AuditregistrationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_auditregistration_a_p_i_group(_api::AuditregistrationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_auditregistration_a_p_i_group_AuditregistrationApi, "/apis/auditregistration.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_auditregistration_a_p_i_group(_api::AuditregistrationApi; _mediaType=nothing) - _ctx = _oacinternal_get_auditregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_auditregistration_a_p_i_group(_api::AuditregistrationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_auditregistration_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_auditregistration_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AuditregistrationV1alpha1Api.jl b/src/ApiImpl/api/apis/api_AuditregistrationV1alpha1Api.jl deleted file mode 100644 index a675e1a2..00000000 --- a/src/ApiImpl/api/apis/api_AuditregistrationV1alpha1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuditregistrationV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuditregistrationV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuditregistrationV1alpha1Api }) = "http://localhost" - -const _returntypes_create_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an AuditSink - -Params: -- body::IoK8sApiAuditregistrationV1alpha1AuditSink (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAuditregistrationV1alpha1AuditSink, OpenAPI.Clients.ApiResponse -""" -function create_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_auditregistration_v1alpha1_audit_sink(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_auditregistration_v1alpha1_audit_sink(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an AuditSink - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_auditregistration_v1alpha1_audit_sink(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_auditregistration_v1alpha1_audit_sink(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_auditregistration_v1alpha1_collection_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_auditregistration_v1alpha1_collection_audit_sink(_api::AuditregistrationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_auditregistration_v1alpha1_collection_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of AuditSink - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_auditregistration_v1alpha1_collection_audit_sink(_api::AuditregistrationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_auditregistration_v1alpha1_collection_audit_sink(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_auditregistration_v1alpha1_collection_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_auditregistration_v1alpha1_collection_audit_sink(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_auditregistration_v1alpha1_a_p_i_resources_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_auditregistration_v1alpha1_a_p_i_resources(_api::AuditregistrationV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_auditregistration_v1alpha1_a_p_i_resources_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_auditregistration_v1alpha1_a_p_i_resources(_api::AuditregistrationV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_auditregistration_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_auditregistration_v1alpha1_a_p_i_resources(_api::AuditregistrationV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_auditregistration_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSinkList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind AuditSink - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAuditregistrationV1alpha1AuditSinkList, OpenAPI.Clients.ApiResponse -""" -function list_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_auditregistration_v1alpha1_audit_sink(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_auditregistration_v1alpha1_audit_sink(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified AuditSink - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAuditregistrationV1alpha1AuditSink, OpenAPI.Clients.ApiResponse -""" -function patch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_auditregistration_v1alpha1_audit_sink(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_auditregistration_v1alpha1_audit_sink(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified AuditSink - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAuditregistrationV1alpha1AuditSink, OpenAPI.Clients.ApiResponse -""" -function read_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_auditregistration_v1alpha1_audit_sink(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_auditregistration_v1alpha1_audit_sink(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuditregistrationV1alpha1AuditSink, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/auditsinks/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified AuditSink - -Params: -- name::String (required) -- body::IoK8sApiAuditregistrationV1alpha1AuditSink (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAuditregistrationV1alpha1AuditSink, OpenAPI.Clients.ApiResponse -""" -function replace_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_auditregistration_v1alpha1_audit_sink(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiAuditregistrationV1alpha1AuditSink; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_auditregistration_v1alpha1_audit_sink(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_auditregistration_v1alpha1_audit_sink_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind AuditSink. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_auditregistration_v1alpha1_audit_sink(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_auditregistration_v1alpha1_audit_sink(_api::AuditregistrationV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_auditregistration_v1alpha1_audit_sink(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_auditregistration_v1alpha1_audit_sink_list_AuditregistrationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_auditregistration_v1alpha1_audit_sink_list(_api::AuditregistrationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_auditregistration_v1alpha1_audit_sink_list_AuditregistrationV1alpha1Api, "/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of AuditSink. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_auditregistration_v1alpha1_audit_sink_list(_api::AuditregistrationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_auditregistration_v1alpha1_audit_sink_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_auditregistration_v1alpha1_audit_sink_list(_api::AuditregistrationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_auditregistration_v1alpha1_audit_sink_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_auditregistration_v1alpha1_audit_sink -export delete_auditregistration_v1alpha1_audit_sink -export delete_auditregistration_v1alpha1_collection_audit_sink -export get_auditregistration_v1alpha1_a_p_i_resources -export list_auditregistration_v1alpha1_audit_sink -export patch_auditregistration_v1alpha1_audit_sink -export read_auditregistration_v1alpha1_audit_sink -export replace_auditregistration_v1alpha1_audit_sink -export watch_auditregistration_v1alpha1_audit_sink -export watch_auditregistration_v1alpha1_audit_sink_list diff --git a/src/ApiImpl/api/apis/api_AuthenticationApi.jl b/src/ApiImpl/api/apis/api_AuthenticationApi.jl deleted file mode 100644 index e2d16dfa..00000000 --- a/src/ApiImpl/api/apis/api_AuthenticationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthenticationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthenticationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthenticationApi }) = "http://localhost" - -const _returntypes_get_authentication_a_p_i_group_AuthenticationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authentication_a_p_i_group(_api::AuthenticationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authentication_a_p_i_group_AuthenticationApi, "/apis/authentication.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_authentication_a_p_i_group(_api::AuthenticationApi; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authentication_a_p_i_group(_api::AuthenticationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_authentication_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AuthenticationV1Api.jl b/src/ApiImpl/api/apis/api_AuthenticationV1Api.jl deleted file mode 100644 index cea6091c..00000000 --- a/src/ApiImpl/api/apis/api_AuthenticationV1Api.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthenticationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthenticationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthenticationV1Api }) = "http://localhost" - -const _returntypes_create_authentication_v1_token_review_AuthenticationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authentication_v1_token_review(_api::AuthenticationV1Api, body::IoK8sApiAuthenticationV1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authentication_v1_token_review_AuthenticationV1Api, "/apis/authentication.k8s.io/v1/tokenreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a TokenReview - -Params: -- body::IoK8sApiAuthenticationV1TokenReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthenticationV1TokenReview, OpenAPI.Clients.ApiResponse -""" -function create_authentication_v1_token_review(_api::AuthenticationV1Api, body::IoK8sApiAuthenticationV1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authentication_v1_token_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authentication_v1_token_review(_api::AuthenticationV1Api, response_stream::Channel, body::IoK8sApiAuthenticationV1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authentication_v1_token_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_authentication_v1_a_p_i_resources_AuthenticationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authentication_v1_a_p_i_resources(_api::AuthenticationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authentication_v1_a_p_i_resources_AuthenticationV1Api, "/apis/authentication.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_authentication_v1_a_p_i_resources(_api::AuthenticationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authentication_v1_a_p_i_resources(_api::AuthenticationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_authentication_v1_token_review -export get_authentication_v1_a_p_i_resources diff --git a/src/ApiImpl/api/apis/api_AuthenticationV1beta1Api.jl b/src/ApiImpl/api/apis/api_AuthenticationV1beta1Api.jl deleted file mode 100644 index 88248b17..00000000 --- a/src/ApiImpl/api/apis/api_AuthenticationV1beta1Api.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthenticationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthenticationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthenticationV1beta1Api }) = "http://localhost" - -const _returntypes_create_authentication_v1beta1_token_review_AuthenticationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthenticationV1beta1TokenReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthenticationV1beta1TokenReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthenticationV1beta1TokenReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authentication_v1beta1_token_review(_api::AuthenticationV1beta1Api, body::IoK8sApiAuthenticationV1beta1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authentication_v1beta1_token_review_AuthenticationV1beta1Api, "/apis/authentication.k8s.io/v1beta1/tokenreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a TokenReview - -Params: -- body::IoK8sApiAuthenticationV1beta1TokenReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthenticationV1beta1TokenReview, OpenAPI.Clients.ApiResponse -""" -function create_authentication_v1beta1_token_review(_api::AuthenticationV1beta1Api, body::IoK8sApiAuthenticationV1beta1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authentication_v1beta1_token_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authentication_v1beta1_token_review(_api::AuthenticationV1beta1Api, response_stream::Channel, body::IoK8sApiAuthenticationV1beta1TokenReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authentication_v1beta1_token_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_authentication_v1beta1_a_p_i_resources_AuthenticationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authentication_v1beta1_a_p_i_resources(_api::AuthenticationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authentication_v1beta1_a_p_i_resources_AuthenticationV1beta1Api, "/apis/authentication.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_authentication_v1beta1_a_p_i_resources(_api::AuthenticationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authentication_v1beta1_a_p_i_resources(_api::AuthenticationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authentication_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_authentication_v1beta1_token_review -export get_authentication_v1beta1_a_p_i_resources diff --git a/src/ApiImpl/api/apis/api_AuthorizationApi.jl b/src/ApiImpl/api/apis/api_AuthorizationApi.jl deleted file mode 100644 index b8b92636..00000000 --- a/src/ApiImpl/api/apis/api_AuthorizationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthorizationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthorizationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthorizationApi }) = "http://localhost" - -const _returntypes_get_authorization_a_p_i_group_AuthorizationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authorization_a_p_i_group(_api::AuthorizationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authorization_a_p_i_group_AuthorizationApi, "/apis/authorization.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_authorization_a_p_i_group(_api::AuthorizationApi; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authorization_a_p_i_group(_api::AuthorizationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_authorization_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AuthorizationV1Api.jl b/src/ApiImpl/api/apis/api_AuthorizationV1Api.jl deleted file mode 100644 index 72350ef4..00000000 --- a/src/ApiImpl/api/apis/api_AuthorizationV1Api.jl +++ /dev/null @@ -1,196 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthorizationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthorizationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthorizationV1Api }) = "http://localhost" - -const _returntypes_create_authorization_v1_namespaced_local_subject_access_review_AuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1LocalSubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1LocalSubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1LocalSubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1_namespaced_local_subject_access_review(_api::AuthorizationV1Api, namespace::String, body::IoK8sApiAuthorizationV1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1_namespaced_local_subject_access_review_AuthorizationV1Api, "/apis/authorization.k8s.io/v1/namespaces/{namespace}/localsubjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a LocalSubjectAccessReview - -Params: -- namespace::String (required) -- body::IoK8sApiAuthorizationV1LocalSubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1LocalSubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1_namespaced_local_subject_access_review(_api::AuthorizationV1Api, namespace::String, body::IoK8sApiAuthorizationV1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_namespaced_local_subject_access_review(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1_namespaced_local_subject_access_review(_api::AuthorizationV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAuthorizationV1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_namespaced_local_subject_access_review(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1_self_subject_access_review_AuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1_self_subject_access_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1_self_subject_access_review_AuthorizationV1Api, "/apis/authorization.k8s.io/v1/selfsubjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SelfSubjectAccessReview - -Params: -- body::IoK8sApiAuthorizationV1SelfSubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1SelfSubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1_self_subject_access_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_self_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1_self_subject_access_review(_api::AuthorizationV1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_self_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1_self_subject_rules_review_AuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectRulesReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectRulesReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SelfSubjectRulesReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1_self_subject_rules_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1_self_subject_rules_review_AuthorizationV1Api, "/apis/authorization.k8s.io/v1/selfsubjectrulesreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SelfSubjectRulesReview - -Params: -- body::IoK8sApiAuthorizationV1SelfSubjectRulesReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1SelfSubjectRulesReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1_self_subject_rules_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_self_subject_rules_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1_self_subject_rules_review(_api::AuthorizationV1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_self_subject_rules_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1_subject_access_review_AuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1SubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1_subject_access_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1_subject_access_review_AuthorizationV1Api, "/apis/authorization.k8s.io/v1/subjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SubjectAccessReview - -Params: -- body::IoK8sApiAuthorizationV1SubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1SubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1_subject_access_review(_api::AuthorizationV1Api, body::IoK8sApiAuthorizationV1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1_subject_access_review(_api::AuthorizationV1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_authorization_v1_a_p_i_resources_AuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authorization_v1_a_p_i_resources(_api::AuthorizationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authorization_v1_a_p_i_resources_AuthorizationV1Api, "/apis/authorization.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_authorization_v1_a_p_i_resources(_api::AuthorizationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authorization_v1_a_p_i_resources(_api::AuthorizationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_authorization_v1_namespaced_local_subject_access_review -export create_authorization_v1_self_subject_access_review -export create_authorization_v1_self_subject_rules_review -export create_authorization_v1_subject_access_review -export get_authorization_v1_a_p_i_resources diff --git a/src/ApiImpl/api/apis/api_AuthorizationV1beta1Api.jl b/src/ApiImpl/api/apis/api_AuthorizationV1beta1Api.jl deleted file mode 100644 index 79a424ab..00000000 --- a/src/ApiImpl/api/apis/api_AuthorizationV1beta1Api.jl +++ /dev/null @@ -1,196 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AuthorizationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AuthorizationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AuthorizationV1beta1Api }) = "http://localhost" - -const _returntypes_create_authorization_v1beta1_namespaced_local_subject_access_review_AuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1beta1_namespaced_local_subject_access_review(_api::AuthorizationV1beta1Api, namespace::String, body::IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1beta1_namespaced_local_subject_access_review_AuthorizationV1beta1Api, "/apis/authorization.k8s.io/v1beta1/namespaces/{namespace}/localsubjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a LocalSubjectAccessReview - -Params: -- namespace::String (required) -- body::IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1beta1_namespaced_local_subject_access_review(_api::AuthorizationV1beta1Api, namespace::String, body::IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_namespaced_local_subject_access_review(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1beta1_namespaced_local_subject_access_review(_api::AuthorizationV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_namespaced_local_subject_access_review(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1beta1_self_subject_access_review_AuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1beta1_self_subject_access_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1beta1_self_subject_access_review_AuthorizationV1beta1Api, "/apis/authorization.k8s.io/v1beta1/selfsubjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SelfSubjectAccessReview - -Params: -- body::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1beta1_self_subject_access_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_self_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1beta1_self_subject_access_review(_api::AuthorizationV1beta1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_self_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1beta1_self_subject_rules_review_AuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1beta1_self_subject_rules_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1beta1_self_subject_rules_review_AuthorizationV1beta1Api, "/apis/authorization.k8s.io/v1beta1/selfsubjectrulesreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SelfSubjectRulesReview - -Params: -- body::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1beta1_self_subject_rules_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_self_subject_rules_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1beta1_self_subject_rules_review(_api::AuthorizationV1beta1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_self_subject_rules_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_authorization_v1beta1_subject_access_review_AuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SubjectAccessReview, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SubjectAccessReview, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthorizationV1beta1SubjectAccessReview, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_authorization_v1beta1_subject_access_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_authorization_v1beta1_subject_access_review_AuthorizationV1beta1Api, "/apis/authorization.k8s.io/v1beta1/subjectaccessreviews", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a SubjectAccessReview - -Params: -- body::IoK8sApiAuthorizationV1beta1SubjectAccessReview (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthorizationV1beta1SubjectAccessReview, OpenAPI.Clients.ApiResponse -""" -function create_authorization_v1beta1_subject_access_review(_api::AuthorizationV1beta1Api, body::IoK8sApiAuthorizationV1beta1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_authorization_v1beta1_subject_access_review(_api::AuthorizationV1beta1Api, response_stream::Channel, body::IoK8sApiAuthorizationV1beta1SubjectAccessReview; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_authorization_v1beta1_subject_access_review(_api, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_authorization_v1beta1_a_p_i_resources_AuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_authorization_v1beta1_a_p_i_resources(_api::AuthorizationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_authorization_v1beta1_a_p_i_resources_AuthorizationV1beta1Api, "/apis/authorization.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_authorization_v1beta1_a_p_i_resources(_api::AuthorizationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_authorization_v1beta1_a_p_i_resources(_api::AuthorizationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_authorization_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_authorization_v1beta1_namespaced_local_subject_access_review -export create_authorization_v1beta1_self_subject_access_review -export create_authorization_v1beta1_self_subject_rules_review -export create_authorization_v1beta1_subject_access_review -export get_authorization_v1beta1_a_p_i_resources diff --git a/src/ApiImpl/api/apis/api_AutoscalingApi.jl b/src/ApiImpl/api/apis/api_AutoscalingApi.jl deleted file mode 100644 index ed1a88f4..00000000 --- a/src/ApiImpl/api/apis/api_AutoscalingApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AutoscalingApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AutoscalingApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AutoscalingApi }) = "http://localhost" - -const _returntypes_get_autoscaling_a_p_i_group_AutoscalingApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_autoscaling_a_p_i_group(_api::AutoscalingApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_autoscaling_a_p_i_group_AutoscalingApi, "/apis/autoscaling/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_autoscaling_a_p_i_group(_api::AutoscalingApi; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_autoscaling_a_p_i_group(_api::AutoscalingApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_autoscaling_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_AutoscalingV1Api.jl b/src/ApiImpl/api/apis/api_AutoscalingV1Api.jl deleted file mode 100644 index 71987f3d..00000000 --- a/src/ApiImpl/api/apis/api_AutoscalingV1Api.jl +++ /dev/null @@ -1,668 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AutoscalingV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AutoscalingV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AutoscalingV1Api }) = "http://localhost" - -const _returntypes_create_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_autoscaling_v1_a_p_i_resources_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_autoscaling_v1_a_p_i_resources(_api::AutoscalingV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_autoscaling_v1_a_p_i_resources_AutoscalingV1Api, "/apis/autoscaling/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_autoscaling_v1_a_p_i_resources(_api::AutoscalingV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_autoscaling_v1_a_p_i_resources(_api::AutoscalingV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV1Api, "/apis/autoscaling/v1/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV1Api, "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV1Api, "/apis/autoscaling/v1/watch/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_AutoscalingV1Api, "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list_AutoscalingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list_AutoscalingV1Api, "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export get_autoscaling_v1_a_p_i_resources -export list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces -export list_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status -export read_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status -export replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status -export watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces -export watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler -export watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list diff --git a/src/ApiImpl/api/apis/api_AutoscalingV2beta1Api.jl b/src/ApiImpl/api/apis/api_AutoscalingV2beta1Api.jl deleted file mode 100644 index 3fe31020..00000000 --- a/src/ApiImpl/api/apis/api_AutoscalingV2beta1Api.jl +++ /dev/null @@ -1,668 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AutoscalingV2beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AutoscalingV2beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AutoscalingV2beta1Api }) = "http://localhost" - -const _returntypes_create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_autoscaling_v2beta1_a_p_i_resources_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_autoscaling_v2beta1_a_p_i_resources(_api::AutoscalingV2beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_autoscaling_v2beta1_a_p_i_resources_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_autoscaling_v2beta1_a_p_i_resources(_api::AutoscalingV2beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v2beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_autoscaling_v2beta1_a_p_i_resources(_api::AutoscalingV2beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v2beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/watch/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list_AutoscalingV2beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list_AutoscalingV2beta1Api, "/apis/autoscaling/v2beta1/watch/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export get_autoscaling_v2beta1_a_p_i_resources -export list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces -export list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status -export read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status -export replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status -export watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces -export watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler -export watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list diff --git a/src/ApiImpl/api/apis/api_AutoscalingV2beta2Api.jl b/src/ApiImpl/api/apis/api_AutoscalingV2beta2Api.jl deleted file mode 100644 index 1682d223..00000000 --- a/src/ApiImpl/api/apis/api_AutoscalingV2beta2Api.jl +++ /dev/null @@ -1,668 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct AutoscalingV2beta2Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `AutoscalingV2beta2Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ AutoscalingV2beta2Api }) = "http://localhost" - -const _returntypes_create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_autoscaling_v2beta2_a_p_i_resources_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_autoscaling_v2beta2_a_p_i_resources(_api::AutoscalingV2beta2Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_autoscaling_v2beta2_a_p_i_resources_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_autoscaling_v2beta2_a_p_i_resources(_api::AutoscalingV2beta2Api; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v2beta2_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_autoscaling_v2beta2_a_p_i_resources(_api::AutoscalingV2beta2Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_autoscaling_v2beta2_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api::AutoscalingV2beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind HorizontalPodAutoscaler - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, OpenAPI.Clients.ApiResponse -""" -function list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified HorizontalPodAutoscaler - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, OpenAPI.Clients.ApiResponse -""" -function replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/watch/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta2Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api::AutoscalingV2beta2Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::AutoscalingV2beta2Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list_AutoscalingV2beta2Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list_AutoscalingV2beta2Api, "/apis/autoscaling/v2beta2/watch/namespaces/{namespace}/horizontalpodautoscalers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta2Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api::AutoscalingV2beta2Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler -export delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export get_autoscaling_v2beta2_a_p_i_resources -export list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces -export list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status -export read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status -export replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status -export watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces -export watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler -export watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list diff --git a/src/ApiImpl/api/apis/api_BatchApi.jl b/src/ApiImpl/api/apis/api_BatchApi.jl deleted file mode 100644 index 5b35859c..00000000 --- a/src/ApiImpl/api/apis/api_BatchApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct BatchApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `BatchApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ BatchApi }) = "http://localhost" - -const _returntypes_get_batch_a_p_i_group_BatchApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_batch_a_p_i_group(_api::BatchApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_batch_a_p_i_group_BatchApi, "/apis/batch/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_batch_a_p_i_group(_api::BatchApi; _mediaType=nothing) - _ctx = _oacinternal_get_batch_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_batch_a_p_i_group(_api::BatchApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_batch_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_batch_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_BatchV1Api.jl b/src/ApiImpl/api/apis/api_BatchV1Api.jl deleted file mode 100644 index 265e6655..00000000 --- a/src/ApiImpl/api/apis/api_BatchV1Api.jl +++ /dev/null @@ -1,1300 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct BatchV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `BatchV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ BatchV1Api }) = "http://localhost" - -const _returntypes_create_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_batch_v1_namespaced_cron_job(_api::BatchV1Api, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CronJob - -Params: -- namespace::String (required) -- body::IoK8sApiBatchV1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function create_batch_v1_namespaced_cron_job(_api::BatchV1Api, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_batch_v1_namespaced_job(_api::BatchV1Api, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Job - -Params: -- namespace::String (required) -- body::IoK8sApiBatchV1Job (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function create_batch_v1_namespaced_job(_api::BatchV1Api, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1_namespaced_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1_namespaced_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1_collection_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1_collection_namespaced_cron_job(_api::BatchV1Api, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1_collection_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CronJob - -Params: -- namespace::String (required) -- pretty::String -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1_collection_namespaced_cron_job(_api::BatchV1Api, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1_collection_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1_collection_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1_collection_namespaced_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1_collection_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Job - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1_collection_namespaced_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_collection_namespaced_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1_collection_namespaced_job(_api::BatchV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_collection_namespaced_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Job - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_namespaced_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1_namespaced_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_batch_v1_a_p_i_resources_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_batch_v1_a_p_i_resources(_api::BatchV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_batch_v1_a_p_i_resources_BatchV1Api, "/apis/batch/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_batch_v1_a_p_i_resources(_api::BatchV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_batch_v1_a_p_i_resources(_api::BatchV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1_cron_job_for_all_namespaces_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1_cron_job_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1_cron_job_for_all_namespaces_BatchV1Api, "/apis/batch/v1/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1_cron_job_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1_cron_job_for_all_namespaces(_api::BatchV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1_job_for_all_namespaces_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1JobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1_job_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1_job_for_all_namespaces_BatchV1Api, "/apis/batch/v1/jobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Job - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1JobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1_job_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1_job_for_all_namespaces(_api::BatchV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1_namespaced_cron_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1_namespaced_cron_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1JobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1_namespaced_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Job - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1JobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1_namespaced_job(_api::BatchV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_namespaced_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1_namespaced_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1_namespaced_cron_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1_namespaced_cron_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1_namespaced_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1_namespaced_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1_namespaced_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1_namespaced_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_cron_job(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_cron_job(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1_namespaced_cron_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1_namespaced_cron_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1_namespaced_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1_namespaced_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1_namespaced_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1_namespaced_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1_namespaced_cron_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1_namespaced_cron_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1_namespaced_cron_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1Job (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1_namespaced_job_status_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1Job, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1_namespaced_job_status_BatchV1Api, "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Job - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1Job (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1Job, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1_namespaced_job_status(_api::BatchV1Api, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1_namespaced_job_status(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1Job; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1_namespaced_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_cron_job_list_for_all_namespaces_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_cron_job_list_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_cron_job_list_for_all_namespaces_BatchV1Api, "/apis/batch/v1/watch/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_cron_job_list_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_cron_job_list_for_all_namespaces(_api::BatchV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_job_list_for_all_namespaces_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_job_list_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_job_list_for_all_namespaces_BatchV1Api, "/apis/batch/v1/watch/jobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_job_list_for_all_namespaces(_api::BatchV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_job_list_for_all_namespaces(_api::BatchV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_namespaced_cron_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_namespaced_cron_job_BatchV1Api, "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_namespaced_cron_job(_api::BatchV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_namespaced_cron_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_namespaced_cron_job_list_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_namespaced_cron_job_list(_api::BatchV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_namespaced_cron_job_list_BatchV1Api, "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_namespaced_cron_job_list(_api::BatchV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_namespaced_cron_job_list(_api::BatchV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_namespaced_job_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_namespaced_job_BatchV1Api, "/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_namespaced_job(_api::BatchV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_namespaced_job(_api::BatchV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1_namespaced_job_list_BatchV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1_namespaced_job_list(_api::BatchV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1_namespaced_job_list_BatchV1Api, "/apis/batch/v1/watch/namespaces/{namespace}/jobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1_namespaced_job_list(_api::BatchV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1_namespaced_job_list(_api::BatchV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1_namespaced_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_batch_v1_namespaced_cron_job -export create_batch_v1_namespaced_job -export delete_batch_v1_collection_namespaced_cron_job -export delete_batch_v1_collection_namespaced_job -export delete_batch_v1_namespaced_cron_job -export delete_batch_v1_namespaced_job -export get_batch_v1_a_p_i_resources -export list_batch_v1_cron_job_for_all_namespaces -export list_batch_v1_job_for_all_namespaces -export list_batch_v1_namespaced_cron_job -export list_batch_v1_namespaced_job -export patch_batch_v1_namespaced_cron_job -export patch_batch_v1_namespaced_cron_job_status -export patch_batch_v1_namespaced_job -export patch_batch_v1_namespaced_job_status -export read_batch_v1_namespaced_cron_job -export read_batch_v1_namespaced_cron_job_status -export read_batch_v1_namespaced_job -export read_batch_v1_namespaced_job_status -export replace_batch_v1_namespaced_cron_job -export replace_batch_v1_namespaced_cron_job_status -export replace_batch_v1_namespaced_job -export replace_batch_v1_namespaced_job_status -export watch_batch_v1_cron_job_list_for_all_namespaces -export watch_batch_v1_job_list_for_all_namespaces -export watch_batch_v1_namespaced_cron_job -export watch_batch_v1_namespaced_cron_job_list -export watch_batch_v1_namespaced_job -export watch_batch_v1_namespaced_job_list diff --git a/src/ApiImpl/api/apis/api_BatchV1beta1Api.jl b/src/ApiImpl/api/apis/api_BatchV1beta1Api.jl deleted file mode 100644 index 1b4fcddf..00000000 --- a/src/ApiImpl/api/apis/api_BatchV1beta1Api.jl +++ /dev/null @@ -1,678 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct BatchV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `BatchV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ BatchV1beta1Api }) = "http://localhost" - -const _returntypes_create_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CronJob - -Params: -- namespace::String (required) -- body::IoK8sApiBatchV1beta1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function create_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1beta1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v1beta1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1beta1_collection_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1beta1_collection_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1beta1_collection_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CronJob - -Params: -- namespace::String (required) -- pretty::String -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1beta1_collection_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1beta1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1beta1_collection_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1beta1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1beta1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v1beta1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_batch_v1beta1_a_p_i_resources_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_batch_v1beta1_a_p_i_resources(_api::BatchV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_batch_v1beta1_a_p_i_resources_BatchV1beta1Api, "/apis/batch/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_batch_v1beta1_a_p_i_resources(_api::BatchV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_batch_v1beta1_a_p_i_resources(_api::BatchV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1beta1_cron_job_for_all_namespaces_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1beta1_cron_job_for_all_namespaces(_api::BatchV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1beta1_cron_job_for_all_namespaces_BatchV1beta1Api, "/apis/batch/v1beta1/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1beta1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1beta1_cron_job_for_all_namespaces(_api::BatchV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1beta1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1beta1_cron_job_for_all_namespaces(_api::BatchV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1beta1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV1beta1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1beta1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v1beta1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1beta1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1beta1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1beta1_namespaced_cron_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1beta1_namespaced_cron_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1beta1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1beta1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1beta1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV1beta1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v1beta1_namespaced_cron_job_status_BatchV1beta1Api, "/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV1beta1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV1beta1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v1beta1_namespaced_cron_job_status(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV1beta1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v1beta1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1beta1_cron_job_list_for_all_namespaces_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api::BatchV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1beta1_cron_job_list_for_all_namespaces_BatchV1beta1Api, "/apis/batch/v1beta1/watch/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api::BatchV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api::BatchV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1beta1_namespaced_cron_job_BatchV1beta1Api, "/apis/batch/v1beta1/watch/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1beta1_namespaced_cron_job(_api::BatchV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v1beta1_namespaced_cron_job_list_BatchV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v1beta1_namespaced_cron_job_list(_api::BatchV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v1beta1_namespaced_cron_job_list_BatchV1beta1Api, "/apis/batch/v1beta1/watch/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v1beta1_namespaced_cron_job_list(_api::BatchV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v1beta1_namespaced_cron_job_list(_api::BatchV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v1beta1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_batch_v1beta1_namespaced_cron_job -export delete_batch_v1beta1_collection_namespaced_cron_job -export delete_batch_v1beta1_namespaced_cron_job -export get_batch_v1beta1_a_p_i_resources -export list_batch_v1beta1_cron_job_for_all_namespaces -export list_batch_v1beta1_namespaced_cron_job -export patch_batch_v1beta1_namespaced_cron_job -export patch_batch_v1beta1_namespaced_cron_job_status -export read_batch_v1beta1_namespaced_cron_job -export read_batch_v1beta1_namespaced_cron_job_status -export replace_batch_v1beta1_namespaced_cron_job -export replace_batch_v1beta1_namespaced_cron_job_status -export watch_batch_v1beta1_cron_job_list_for_all_namespaces -export watch_batch_v1beta1_namespaced_cron_job -export watch_batch_v1beta1_namespaced_cron_job_list diff --git a/src/ApiImpl/api/apis/api_BatchV2alpha1Api.jl b/src/ApiImpl/api/apis/api_BatchV2alpha1Api.jl deleted file mode 100644 index c14164aa..00000000 --- a/src/ApiImpl/api/apis/api_BatchV2alpha1Api.jl +++ /dev/null @@ -1,668 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct BatchV2alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `BatchV2alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ BatchV2alpha1Api }) = "http://localhost" - -const _returntypes_create_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CronJob - -Params: -- namespace::String (required) -- body::IoK8sApiBatchV2alpha1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function create_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v2alpha1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_batch_v2alpha1_namespaced_cron_job(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v2alpha1_collection_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v2alpha1_collection_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v2alpha1_collection_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CronJob - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v2alpha1_collection_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v2alpha1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v2alpha1_collection_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v2alpha1_collection_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_batch_v2alpha1_a_p_i_resources_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_batch_v2alpha1_a_p_i_resources(_api::BatchV2alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_batch_v2alpha1_a_p_i_resources_BatchV2alpha1Api, "/apis/batch/v2alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_batch_v2alpha1_a_p_i_resources(_api::BatchV2alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v2alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_batch_v2alpha1_a_p_i_resources(_api::BatchV2alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_batch_v2alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v2alpha1_cron_job_for_all_namespaces_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v2alpha1_cron_job_for_all_namespaces(_api::BatchV2alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v2alpha1_cron_job_for_all_namespaces_BatchV2alpha1Api, "/apis/batch/v2alpha1/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV2alpha1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v2alpha1_cron_job_for_all_namespaces(_api::BatchV2alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v2alpha1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v2alpha1_cron_job_for_all_namespaces(_api::BatchV2alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v2alpha1_cron_job_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJobList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CronJob - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiBatchV2alpha1CronJobList, OpenAPI.Clients.ApiResponse -""" -function list_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v2alpha1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_batch_v2alpha1_namespaced_cron_job(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v2alpha1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v2alpha1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function patch_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function read_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV2alpha1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v2alpha1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v2alpha1_namespaced_cron_job(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiBatchV2alpha1CronJob, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_batch_v2alpha1_namespaced_cron_job_status_BatchV2alpha1Api, "/apis/batch/v2alpha1/namespaces/{namespace}/cronjobs/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CronJob - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiBatchV2alpha1CronJob (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiBatchV2alpha1CronJob, OpenAPI.Clients.ApiResponse -""" -function replace_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_batch_v2alpha1_namespaced_cron_job_status(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiBatchV2alpha1CronJob; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_batch_v2alpha1_namespaced_cron_job_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v2alpha1_cron_job_list_for_all_namespaces_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api::BatchV2alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v2alpha1_cron_job_list_for_all_namespaces_BatchV2alpha1Api, "/apis/batch/v2alpha1/watch/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api::BatchV2alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api::BatchV2alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v2alpha1_namespaced_cron_job_BatchV2alpha1Api, "/apis/batch/v2alpha1/watch/namespaces/{namespace}/cronjobs/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v2alpha1_namespaced_cron_job(_api::BatchV2alpha1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_namespaced_cron_job(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_batch_v2alpha1_namespaced_cron_job_list_BatchV2alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_batch_v2alpha1_namespaced_cron_job_list(_api::BatchV2alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_batch_v2alpha1_namespaced_cron_job_list_BatchV2alpha1Api, "/apis/batch/v2alpha1/watch/namespaces/{namespace}/cronjobs", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_batch_v2alpha1_namespaced_cron_job_list(_api::BatchV2alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_batch_v2alpha1_namespaced_cron_job_list(_api::BatchV2alpha1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_batch_v2alpha1_namespaced_cron_job_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_batch_v2alpha1_namespaced_cron_job -export delete_batch_v2alpha1_collection_namespaced_cron_job -export delete_batch_v2alpha1_namespaced_cron_job -export get_batch_v2alpha1_a_p_i_resources -export list_batch_v2alpha1_cron_job_for_all_namespaces -export list_batch_v2alpha1_namespaced_cron_job -export patch_batch_v2alpha1_namespaced_cron_job -export patch_batch_v2alpha1_namespaced_cron_job_status -export read_batch_v2alpha1_namespaced_cron_job -export read_batch_v2alpha1_namespaced_cron_job_status -export replace_batch_v2alpha1_namespaced_cron_job -export replace_batch_v2alpha1_namespaced_cron_job_status -export watch_batch_v2alpha1_cron_job_list_for_all_namespaces -export watch_batch_v2alpha1_namespaced_cron_job -export watch_batch_v2alpha1_namespaced_cron_job_list diff --git a/src/ApiImpl/api/apis/api_CertificatesApi.jl b/src/ApiImpl/api/apis/api_CertificatesApi.jl deleted file mode 100644 index 948918be..00000000 --- a/src/ApiImpl/api/apis/api_CertificatesApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CertificatesApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CertificatesApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CertificatesApi }) = "http://localhost" - -const _returntypes_get_certificates_a_p_i_group_CertificatesApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_certificates_a_p_i_group(_api::CertificatesApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_certificates_a_p_i_group_CertificatesApi, "/apis/certificates.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_certificates_a_p_i_group(_api::CertificatesApi; _mediaType=nothing) - _ctx = _oacinternal_get_certificates_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_certificates_a_p_i_group(_api::CertificatesApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_certificates_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_certificates_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_CertificatesV1beta1Api.jl b/src/ApiImpl/api/apis/api_CertificatesV1beta1Api.jl deleted file mode 100644 index 1675b1e7..00000000 --- a/src/ApiImpl/api/apis/api_CertificatesV1beta1Api.jl +++ /dev/null @@ -1,589 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CertificatesV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CertificatesV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CertificatesV1beta1Api }) = "http://localhost" - -const _returntypes_create_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CertificateSigningRequest - -Params: -- body::IoK8sApiCertificatesV1beta1CertificateSigningRequest (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function create_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_certificates_v1beta1_certificate_signing_request(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_certificates_v1beta1_certificate_signing_request(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CertificateSigningRequest - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_certificates_v1beta1_certificate_signing_request(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_certificates_v1beta1_certificate_signing_request(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_certificates_v1beta1_collection_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_certificates_v1beta1_collection_certificate_signing_request(_api::CertificatesV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_certificates_v1beta1_collection_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CertificateSigningRequest - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_certificates_v1beta1_collection_certificate_signing_request(_api::CertificatesV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_certificates_v1beta1_collection_certificate_signing_request(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_certificates_v1beta1_collection_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_certificates_v1beta1_collection_certificate_signing_request(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_certificates_v1beta1_a_p_i_resources_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_certificates_v1beta1_a_p_i_resources(_api::CertificatesV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_certificates_v1beta1_a_p_i_resources_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_certificates_v1beta1_a_p_i_resources(_api::CertificatesV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_certificates_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_certificates_v1beta1_a_p_i_resources(_api::CertificatesV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_certificates_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequestList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CertificateSigningRequest - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequestList, OpenAPI.Clients.ApiResponse -""" -function list_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_certificates_v1beta1_certificate_signing_request(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_certificates_v1beta1_certificate_signing_request(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CertificateSigningRequest - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function patch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_certificates_v1beta1_certificate_signing_request(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_certificates_v1beta1_certificate_signing_request(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified CertificateSigningRequest - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function patch_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_certificates_v1beta1_certificate_signing_request_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_certificates_v1beta1_certificate_signing_request_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CertificateSigningRequest - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function read_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_certificates_v1beta1_certificate_signing_request(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_certificates_v1beta1_certificate_signing_request(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified CertificateSigningRequest - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function read_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_certificates_v1beta1_certificate_signing_request_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_certificates_v1beta1_certificate_signing_request_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CertificateSigningRequest - -Params: -- name::String (required) -- body::IoK8sApiCertificatesV1beta1CertificateSigningRequest (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function replace_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_certificates_v1beta1_certificate_signing_request_approval_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_certificates_v1beta1_certificate_signing_request_approval(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_certificates_v1beta1_certificate_signing_request_approval_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}/approval", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace approval of the specified CertificateSigningRequest - -Params: -- name::String (required) -- body::IoK8sApiCertificatesV1beta1CertificateSigningRequest (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function replace_certificates_v1beta1_certificate_signing_request_approval(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request_approval(_api, name, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_certificates_v1beta1_certificate_signing_request_approval(_api::CertificatesV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request_approval(_api, name, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCertificatesV1beta1CertificateSigningRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_certificates_v1beta1_certificate_signing_request_status_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified CertificateSigningRequest - -Params: -- name::String (required) -- body::IoK8sApiCertificatesV1beta1CertificateSigningRequest (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCertificatesV1beta1CertificateSigningRequest, OpenAPI.Clients.ApiResponse -""" -function replace_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_certificates_v1beta1_certificate_signing_request_status(_api::CertificatesV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiCertificatesV1beta1CertificateSigningRequest; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_certificates_v1beta1_certificate_signing_request_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_certificates_v1beta1_certificate_signing_request_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_certificates_v1beta1_certificate_signing_request(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_certificates_v1beta1_certificate_signing_request(_api::CertificatesV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_certificates_v1beta1_certificate_signing_request(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_certificates_v1beta1_certificate_signing_request_list_CertificatesV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_certificates_v1beta1_certificate_signing_request_list(_api::CertificatesV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_certificates_v1beta1_certificate_signing_request_list_CertificatesV1beta1Api, "/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_certificates_v1beta1_certificate_signing_request_list(_api::CertificatesV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_certificates_v1beta1_certificate_signing_request_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_certificates_v1beta1_certificate_signing_request_list(_api::CertificatesV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_certificates_v1beta1_certificate_signing_request_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_certificates_v1beta1_certificate_signing_request -export delete_certificates_v1beta1_certificate_signing_request -export delete_certificates_v1beta1_collection_certificate_signing_request -export get_certificates_v1beta1_a_p_i_resources -export list_certificates_v1beta1_certificate_signing_request -export patch_certificates_v1beta1_certificate_signing_request -export patch_certificates_v1beta1_certificate_signing_request_status -export read_certificates_v1beta1_certificate_signing_request -export read_certificates_v1beta1_certificate_signing_request_status -export replace_certificates_v1beta1_certificate_signing_request -export replace_certificates_v1beta1_certificate_signing_request_approval -export replace_certificates_v1beta1_certificate_signing_request_status -export watch_certificates_v1beta1_certificate_signing_request -export watch_certificates_v1beta1_certificate_signing_request_list diff --git a/src/ApiImpl/api/apis/api_CoordinationApi.jl b/src/ApiImpl/api/apis/api_CoordinationApi.jl deleted file mode 100644 index 55dd7102..00000000 --- a/src/ApiImpl/api/apis/api_CoordinationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CoordinationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CoordinationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CoordinationApi }) = "http://localhost" - -const _returntypes_get_coordination_a_p_i_group_CoordinationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_coordination_a_p_i_group(_api::CoordinationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_coordination_a_p_i_group_CoordinationApi, "/apis/coordination.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_coordination_a_p_i_group(_api::CoordinationApi; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_coordination_a_p_i_group(_api::CoordinationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_coordination_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_CoordinationV1Api.jl b/src/ApiImpl/api/apis/api_CoordinationV1Api.jl deleted file mode 100644 index 5a8a24f2..00000000 --- a/src/ApiImpl/api/apis/api_CoordinationV1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CoordinationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CoordinationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CoordinationV1Api }) = "http://localhost" - -const _returntypes_create_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_coordination_v1_namespaced_lease(_api::CoordinationV1Api, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Lease - -Params: -- namespace::String (required) -- body::IoK8sApiCoordinationV1Lease (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoordinationV1Lease, OpenAPI.Clients.ApiResponse -""" -function create_coordination_v1_namespaced_lease(_api::CoordinationV1Api, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_coordination_v1_namespaced_lease(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_coordination_v1_namespaced_lease(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_coordination_v1_collection_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_coordination_v1_collection_namespaced_lease(_api::CoordinationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_coordination_v1_collection_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Lease - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_coordination_v1_collection_namespaced_lease(_api::CoordinationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1_collection_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_coordination_v1_collection_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1_collection_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Lease - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1_namespaced_lease(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1_namespaced_lease(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_coordination_v1_a_p_i_resources_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_coordination_v1_a_p_i_resources(_api::CoordinationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_coordination_v1_a_p_i_resources_CoordinationV1Api, "/apis/coordination.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_coordination_v1_a_p_i_resources(_api::CoordinationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_coordination_v1_a_p_i_resources(_api::CoordinationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_coordination_v1_lease_for_all_namespaces_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1LeaseList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_coordination_v1_lease_for_all_namespaces(_api::CoordinationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_coordination_v1_lease_for_all_namespaces_CoordinationV1Api, "/apis/coordination.k8s.io/v1/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Lease - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoordinationV1LeaseList, OpenAPI.Clients.ApiResponse -""" -function list_coordination_v1_lease_for_all_namespaces(_api::CoordinationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1_lease_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_coordination_v1_lease_for_all_namespaces(_api::CoordinationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1_lease_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1LeaseList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_coordination_v1_namespaced_lease(_api::CoordinationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Lease - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoordinationV1LeaseList, OpenAPI.Clients.ApiResponse -""" -function list_coordination_v1_namespaced_lease(_api::CoordinationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoordinationV1Lease, OpenAPI.Clients.ApiResponse -""" -function patch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_coordination_v1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_coordination_v1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoordinationV1Lease, OpenAPI.Clients.ApiResponse -""" -function read_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_coordination_v1_namespaced_lease(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_coordination_v1_namespaced_lease(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoordinationV1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoordinationV1Lease (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoordinationV1Lease, OpenAPI.Clients.ApiResponse -""" -function replace_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_coordination_v1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoordinationV1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_coordination_v1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1_lease_list_for_all_namespaces_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1_lease_list_for_all_namespaces(_api::CoordinationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1_lease_list_for_all_namespaces_CoordinationV1Api, "/apis/coordination.k8s.io/v1/watch/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1_lease_list_for_all_namespaces(_api::CoordinationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_lease_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1_lease_list_for_all_namespaces(_api::CoordinationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_lease_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1_namespaced_lease_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1_namespaced_lease_CoordinationV1Api, "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_namespaced_lease(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1_namespaced_lease(_api::CoordinationV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_namespaced_lease(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1_namespaced_lease_list_CoordinationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1_namespaced_lease_list(_api::CoordinationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1_namespaced_lease_list_CoordinationV1Api, "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1_namespaced_lease_list(_api::CoordinationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_namespaced_lease_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1_namespaced_lease_list(_api::CoordinationV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1_namespaced_lease_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_coordination_v1_namespaced_lease -export delete_coordination_v1_collection_namespaced_lease -export delete_coordination_v1_namespaced_lease -export get_coordination_v1_a_p_i_resources -export list_coordination_v1_lease_for_all_namespaces -export list_coordination_v1_namespaced_lease -export patch_coordination_v1_namespaced_lease -export read_coordination_v1_namespaced_lease -export replace_coordination_v1_namespaced_lease -export watch_coordination_v1_lease_list_for_all_namespaces -export watch_coordination_v1_namespaced_lease -export watch_coordination_v1_namespaced_lease_list diff --git a/src/ApiImpl/api/apis/api_CoordinationV1beta1Api.jl b/src/ApiImpl/api/apis/api_CoordinationV1beta1Api.jl deleted file mode 100644 index 696d0507..00000000 --- a/src/ApiImpl/api/apis/api_CoordinationV1beta1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CoordinationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CoordinationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CoordinationV1beta1Api }) = "http://localhost" - -const _returntypes_create_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Lease - -Params: -- namespace::String (required) -- body::IoK8sApiCoordinationV1beta1Lease (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoordinationV1beta1Lease, OpenAPI.Clients.ApiResponse -""" -function create_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_coordination_v1beta1_namespaced_lease(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_coordination_v1beta1_namespaced_lease(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_coordination_v1beta1_collection_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_coordination_v1beta1_collection_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_coordination_v1beta1_collection_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Lease - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_coordination_v1beta1_collection_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1beta1_collection_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_coordination_v1beta1_collection_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1beta1_collection_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Lease - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1beta1_namespaced_lease(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_coordination_v1beta1_namespaced_lease(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_coordination_v1beta1_a_p_i_resources_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_coordination_v1beta1_a_p_i_resources(_api::CoordinationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_coordination_v1beta1_a_p_i_resources_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_coordination_v1beta1_a_p_i_resources(_api::CoordinationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_coordination_v1beta1_a_p_i_resources(_api::CoordinationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_coordination_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_coordination_v1beta1_lease_for_all_namespaces_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1LeaseList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_coordination_v1beta1_lease_for_all_namespaces(_api::CoordinationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_coordination_v1beta1_lease_for_all_namespaces_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Lease - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoordinationV1beta1LeaseList, OpenAPI.Clients.ApiResponse -""" -function list_coordination_v1beta1_lease_for_all_namespaces(_api::CoordinationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1beta1_lease_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_coordination_v1beta1_lease_for_all_namespaces(_api::CoordinationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1beta1_lease_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1LeaseList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Lease - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoordinationV1beta1LeaseList, OpenAPI.Clients.ApiResponse -""" -function list_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1beta1_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_coordination_v1beta1_namespaced_lease(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoordinationV1beta1Lease, OpenAPI.Clients.ApiResponse -""" -function patch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_coordination_v1beta1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_coordination_v1beta1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoordinationV1beta1Lease, OpenAPI.Clients.ApiResponse -""" -function read_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_coordination_v1beta1_namespaced_lease(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_coordination_v1beta1_namespaced_lease(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoordinationV1beta1Lease, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/namespaces/{namespace}/leases/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Lease - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoordinationV1beta1Lease (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoordinationV1beta1Lease, OpenAPI.Clients.ApiResponse -""" -function replace_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_coordination_v1beta1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoordinationV1beta1Lease; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_coordination_v1beta1_namespaced_lease(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1beta1_lease_list_for_all_namespaces_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1beta1_lease_list_for_all_namespaces(_api::CoordinationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1beta1_lease_list_for_all_namespaces_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/watch/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1beta1_lease_list_for_all_namespaces(_api::CoordinationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_lease_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1beta1_lease_list_for_all_namespaces(_api::CoordinationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_lease_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1beta1_namespaced_lease_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/watch/namespaces/{namespace}/leases/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_namespaced_lease(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1beta1_namespaced_lease(_api::CoordinationV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_namespaced_lease(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_coordination_v1beta1_namespaced_lease_list_CoordinationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_coordination_v1beta1_namespaced_lease_list(_api::CoordinationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_coordination_v1beta1_namespaced_lease_list_CoordinationV1beta1Api, "/apis/coordination.k8s.io/v1beta1/watch/namespaces/{namespace}/leases", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_coordination_v1beta1_namespaced_lease_list(_api::CoordinationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_namespaced_lease_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_coordination_v1beta1_namespaced_lease_list(_api::CoordinationV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_coordination_v1beta1_namespaced_lease_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_coordination_v1beta1_namespaced_lease -export delete_coordination_v1beta1_collection_namespaced_lease -export delete_coordination_v1beta1_namespaced_lease -export get_coordination_v1beta1_a_p_i_resources -export list_coordination_v1beta1_lease_for_all_namespaces -export list_coordination_v1beta1_namespaced_lease -export patch_coordination_v1beta1_namespaced_lease -export read_coordination_v1beta1_namespaced_lease -export replace_coordination_v1beta1_namespaced_lease -export watch_coordination_v1beta1_lease_list_for_all_namespaces -export watch_coordination_v1beta1_namespaced_lease -export watch_coordination_v1beta1_namespaced_lease_list diff --git a/src/ApiImpl/api/apis/api_CoreApi.jl b/src/ApiImpl/api/apis/api_CoreApi.jl deleted file mode 100644 index 1bff3aa1..00000000 --- a/src/ApiImpl/api/apis/api_CoreApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CoreApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CoreApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CoreApi }) = "http://localhost" - -const _returntypes_get_core_a_p_i_versions_CoreApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIVersions, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_core_a_p_i_versions(_api::CoreApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_core_a_p_i_versions_CoreApi, "/api/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available API versions - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIVersions, OpenAPI.Clients.ApiResponse -""" -function get_core_a_p_i_versions(_api::CoreApi; _mediaType=nothing) - _ctx = _oacinternal_get_core_a_p_i_versions(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_core_a_p_i_versions(_api::CoreApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_core_a_p_i_versions(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_core_a_p_i_versions diff --git a/src/ApiImpl/api/apis/api_CoreV1Api.jl b/src/ApiImpl/api/apis/api_CoreV1Api.jl deleted file mode 100644 index 7c366554..00000000 --- a/src/ApiImpl/api/apis/api_CoreV1Api.jl +++ /dev/null @@ -1,10322 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CoreV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CoreV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CoreV1Api }) = "http://localhost" - -const _returntypes_connect_core_v1_delete_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_delete_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_delete_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_delete_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_delete_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_delete_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_delete_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_connect_core_v1_delete_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect DELETE requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_delete_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_delete_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_delete_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_pod_attach_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_pod_attach(_api::CoreV1Api, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_pod_attach_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/attach", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "container", container) # type String - OpenAPI.Clients.set_param(_ctx.query, "stderr", stderr) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdin", stdin) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdout", stdout) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "tty", tty) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to attach of Pod - -Params: -- name::String (required) -- namespace::String (required) -- container::String -- stderr::Bool -- stdin::Bool -- stdout::Bool -- tty::Bool - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_pod_attach(_api::CoreV1Api, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_attach(_api, name, namespace; container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_pod_attach(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_attach(_api, name, namespace; container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_pod_exec_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_pod_exec(_api::CoreV1Api, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_pod_exec_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/exec", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "command", command) # type String - OpenAPI.Clients.set_param(_ctx.query, "container", container) # type String - OpenAPI.Clients.set_param(_ctx.query, "stderr", stderr) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdin", stdin) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdout", stdout) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "tty", tty) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to exec of Pod - -Params: -- name::String (required) -- namespace::String (required) -- command::String -- container::String -- stderr::Bool -- stdin::Bool -- stdout::Bool -- tty::Bool - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_pod_exec(_api::CoreV1Api, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_exec(_api, name, namespace; command=command, container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_pod_exec(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_exec(_api, name, namespace; command=command, container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_pod_portforward_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_pod_portforward(_api::CoreV1Api, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_pod_portforward_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/portforward", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "ports", ports) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to portforward of Pod - -Params: -- name::String (required) -- namespace::String (required) -- ports::Int64 - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_pod_portforward(_api::CoreV1Api, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_portforward(_api, name, namespace; ports=ports, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_pod_portforward(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_portforward(_api, name, namespace; ports=ports, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_get_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_get_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_connect_core_v1_get_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect GET requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_get_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_get_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_get_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_head_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_head_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "HEAD", _returntypes_connect_core_v1_head_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect HEAD requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_head_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_head_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_head_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_options_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_options_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "OPTIONS", _returntypes_connect_core_v1_options_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect OPTIONS requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_options_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_options_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_options_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_patch_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_patch_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_connect_core_v1_patch_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PATCH requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_patch_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_patch_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_patch_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_pod_attach_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_pod_attach(_api::CoreV1Api, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_pod_attach_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/attach", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "container", container) # type String - OpenAPI.Clients.set_param(_ctx.query, "stderr", stderr) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdin", stdin) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdout", stdout) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "tty", tty) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to attach of Pod - -Params: -- name::String (required) -- namespace::String (required) -- container::String -- stderr::Bool -- stdin::Bool -- stdout::Bool -- tty::Bool - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_pod_attach(_api::CoreV1Api, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_attach(_api, name, namespace; container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_pod_attach(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_attach(_api, name, namespace; container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_pod_exec_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_pod_exec(_api::CoreV1Api, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_pod_exec_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/exec", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "command", command) # type String - OpenAPI.Clients.set_param(_ctx.query, "container", container) # type String - OpenAPI.Clients.set_param(_ctx.query, "stderr", stderr) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdin", stdin) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "stdout", stdout) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "tty", tty) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to exec of Pod - -Params: -- name::String (required) -- namespace::String (required) -- command::String -- container::String -- stderr::Bool -- stdin::Bool -- stdout::Bool -- tty::Bool - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_pod_exec(_api::CoreV1Api, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_exec(_api, name, namespace; command=command, container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_pod_exec(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; command=nothing, container=nothing, stderr=nothing, stdin=nothing, stdout=nothing, tty=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_exec(_api, name, namespace; command=command, container=container, stderr=stderr, stdin=stdin, stdout=stdout, tty=tty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_pod_portforward_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_pod_portforward(_api::CoreV1Api, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_pod_portforward_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/portforward", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "ports", ports) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to portforward of Pod - -Params: -- name::String (required) -- namespace::String (required) -- ports::Int64 - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_pod_portforward(_api::CoreV1Api, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_portforward(_api, name, namespace; ports=ports, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_pod_portforward(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; ports=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_portforward(_api, name, namespace; ports=ports, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_post_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_post_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_connect_core_v1_post_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect POST requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_post_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_post_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_post_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_namespaced_pod_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_namespaced_pod_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_namespaced_pod_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_namespaced_pod_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_pod_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_namespaced_pod_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_namespaced_pod_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Pod - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_namespaced_pod_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_namespaced_pod_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_pod_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_namespaced_service_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_namespaced_service_proxy_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_namespaced_service_proxy(_api::CoreV1Api, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_namespaced_service_proxy(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_service_proxy(_api, name, namespace; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_namespaced_service_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_namespaced_service_proxy_with_path_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Service - -Params: -- name::String (required) -- namespace::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_namespaced_service_proxy_with_path(_api::CoreV1Api, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_namespaced_service_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_namespaced_service_proxy_with_path(_api, name, namespace, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_node_proxy_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_node_proxy_CoreV1Api, "/api/v1/nodes/{name}/proxy", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Node - -Params: -- name::String (required) -- path::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_node_proxy(_api::CoreV1Api, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_node_proxy(_api::CoreV1Api, response_stream::Channel, name::String; path=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_node_proxy(_api, name; path=path, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_connect_core_v1_put_node_proxy_with_path_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_connect_core_v1_put_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_connect_core_v1_put_node_proxy_with_path_CoreV1Api, "/api/v1/nodes/{name}/proxy/{path}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "path", path) # type String - OpenAPI.Clients.set_param(_ctx.query, "path", path2) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["*/*", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""connect PUT requests to proxy of Node - -Params: -- name::String (required) -- path::String (required) -- path2::String - -Return: String, OpenAPI.Clients.ApiResponse -""" -function connect_core_v1_put_node_proxy_with_path(_api::CoreV1Api, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function connect_core_v1_put_node_proxy_with_path(_api::CoreV1Api, response_stream::Channel, name::String, path::String; path2=nothing, _mediaType=nothing) - _ctx = _oacinternal_connect_core_v1_put_node_proxy_with_path(_api, name, path; path2=path2, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespace(_api::CoreV1Api, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespace_CoreV1Api, "/api/v1/namespaces", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Namespace - -Params: -- body::IoK8sApiCoreV1Namespace (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespace(_api::CoreV1Api, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespace(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespace(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_binding_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_binding(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_binding_CoreV1Api, "/api/v1/namespaces/{namespace}/bindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Binding - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Binding (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiCoreV1Binding, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_binding(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_binding(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_binding(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_binding(_api, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_config_map(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ConfigMap - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1ConfigMap (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ConfigMap, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_config_map(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_config_map(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_config_map(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_endpoints(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create Endpoints - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Endpoints (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Endpoints, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_endpoints(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_endpoints(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_endpoints(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_event(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an Event - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Event (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Event, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_event(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_event(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_event(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_limit_range(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a LimitRange - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1LimitRange (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1LimitRange, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_limit_range(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_limit_range(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_limit_range(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PersistentVolumeClaim - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1PersistentVolumeClaim (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_persistent_volume_claim(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_persistent_volume_claim(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_pod(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Pod - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Pod (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_pod(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_pod_binding_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Binding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_pod_binding(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_pod_binding_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/binding", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create binding of a Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Binding (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiCoreV1Binding, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_pod_binding(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_binding(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_pod_binding(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Binding; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_binding(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_pod_eviction_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1Eviction, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1Eviction, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1Eviction, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_pod_eviction(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1Eviction; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_pod_eviction_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/eviction", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create eviction of a Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiPolicyV1beta1Eviction (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiPolicyV1beta1Eviction, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_pod_eviction(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1Eviction; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_eviction(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_pod_eviction(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiPolicyV1beta1Eviction; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_eviction(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_pod_template(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PodTemplate - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1PodTemplate (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PodTemplate, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_pod_template(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_template(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_pod_template(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_replication_controller(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ReplicationController - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1ReplicationController (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_replication_controller(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_replication_controller(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_replication_controller(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_resource_quota(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ResourceQuota - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1ResourceQuota (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_resource_quota(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_resource_quota(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_resource_quota(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_secret(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Secret - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Secret (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Secret, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_secret(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_secret(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_secret(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_service(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Service - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1Service (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_service(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_service_account(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ServiceAccount - -Params: -- namespace::String (required) -- body::IoK8sApiCoreV1ServiceAccount (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ServiceAccount, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_service_account(_api::CoreV1Api, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service_account(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service_account(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_namespaced_service_account_token_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenRequest, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenRequest, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiAuthenticationV1TokenRequest, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_namespaced_service_account_token(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiAuthenticationV1TokenRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_namespaced_service_account_token_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create token of a ServiceAccount - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAuthenticationV1TokenRequest (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiAuthenticationV1TokenRequest, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_namespaced_service_account_token(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiAuthenticationV1TokenRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service_account_token(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_namespaced_service_account_token(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAuthenticationV1TokenRequest; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_namespaced_service_account_token(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_node(_api::CoreV1Api, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_node_CoreV1Api, "/api/v1/nodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Node - -Params: -- body::IoK8sApiCoreV1Node (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_node(_api::CoreV1Api, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_node(_api::CoreV1Api, response_stream::Channel, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_core_v1_persistent_volume(_api::CoreV1Api, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PersistentVolume - -Params: -- body::IoK8sApiCoreV1PersistentVolume (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function create_core_v1_persistent_volume(_api::CoreV1Api, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_persistent_volume(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_core_v1_persistent_volume(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_config_map(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ConfigMap - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_config_map(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_config_map(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_config_map(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_endpoints(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Endpoints - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_endpoints(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_endpoints(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_endpoints(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_event(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Event - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_event(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_event(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_limit_range(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of LimitRange - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_limit_range(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_limit_range(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_limit_range(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PersistentVolumeClaim - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_persistent_volume_claim(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_persistent_volume_claim(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_pod(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Pod - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_pod(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_pod(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_pod(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_pod(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_pod_template(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PodTemplate - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_pod_template(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_pod_template(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_pod_template(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_replication_controller(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ReplicationController - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_replication_controller(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_replication_controller(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_replication_controller(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_resource_quota(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ResourceQuota - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_resource_quota(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_resource_quota(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_resource_quota(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_secret(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Secret - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_secret(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_secret(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_secret(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_secret(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_namespaced_service_account(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ServiceAccount - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_namespaced_service_account(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_service_account(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_namespaced_service_account(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_node(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_node_CoreV1Api, "/api/v1/nodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Node - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_node(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_node(_api::CoreV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_collection_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_collection_persistent_volume(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_collection_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PersistentVolume - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_collection_persistent_volume(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_persistent_volume(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_collection_persistent_volume(_api::CoreV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_collection_persistent_volume(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespace(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespace_CoreV1Api, "/api/v1/namespaces/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Namespace - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespace(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespace(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespace(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ConfigMap - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_config_map(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_config_map(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete Endpoints - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_endpoints(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_endpoints(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an Event - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_event(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_event(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a LimitRange - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_limit_range(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_limit_range(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Pod - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_pod(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_pod(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PodTemplate - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_pod_template(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_pod_template(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_replication_controller(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_replication_controller(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_resource_quota(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_resource_quota(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Secret - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_secret(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_secret(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Service - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_service(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_service(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ServiceAccount - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_service_account(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_namespaced_service_account(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_node(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_node_CoreV1Api, "/api/v1/nodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Node - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_node(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_node(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_core_v1_persistent_volume(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PersistentVolume - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_core_v1_persistent_volume(_api::CoreV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_persistent_volume(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_core_v1_persistent_volume(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_core_v1_a_p_i_resources_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_core_v1_a_p_i_resources(_api::CoreV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_core_v1_a_p_i_resources_CoreV1Api, "/api/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_core_v1_a_p_i_resources(_api::CoreV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_core_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_core_v1_a_p_i_resources(_api::CoreV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_core_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_component_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ComponentStatusList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_component_status(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_component_status_CoreV1Api, "/api/v1/componentstatuses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list objects of kind ComponentStatus - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ComponentStatusList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_component_status(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_component_status(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_component_status(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_component_status(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_config_map_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMapList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_config_map_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_config_map_for_all_namespaces_CoreV1Api, "/api/v1/configmaps", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ConfigMap - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ConfigMapList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_config_map_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_config_map_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_config_map_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_config_map_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_endpoints_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1EndpointsList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_endpoints_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_endpoints_for_all_namespaces_CoreV1Api, "/api/v1/endpoints", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Endpoints - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1EndpointsList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_endpoints_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_endpoints_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_endpoints_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_endpoints_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_event_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1EventList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_event_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_event_for_all_namespaces_CoreV1Api, "/api/v1/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Event - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1EventList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_event_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_event_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_event_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_event_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_limit_range_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRangeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_limit_range_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_limit_range_for_all_namespaces_CoreV1Api, "/api/v1/limitranges", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind LimitRange - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1LimitRangeList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_limit_range_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_limit_range_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_limit_range_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_limit_range_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1NamespaceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespace(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespace_CoreV1Api, "/api/v1/namespaces", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Namespace - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1NamespaceList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespace(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespace(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespace(_api::CoreV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespace(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMapList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_config_map(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ConfigMap - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ConfigMapList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_config_map(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_config_map(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_config_map(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1EndpointsList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_endpoints(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Endpoints - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1EndpointsList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_endpoints(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_endpoints(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_endpoints(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1EventList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_event(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Event - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1EventList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_event(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRangeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_limit_range(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind LimitRange - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1LimitRangeList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_limit_range(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_limit_range(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_limit_range(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaimList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PersistentVolumeClaim - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PersistentVolumeClaimList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_persistent_volume_claim(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_persistent_volume_claim(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_pod(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Pod - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PodList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_pod(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_pod(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_pod(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplateList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_pod_template(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodTemplate - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PodTemplateList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_pod_template(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_pod_template(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_pod_template(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationControllerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_replication_controller(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicationController - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ReplicationControllerList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_replication_controller(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_replication_controller(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_replication_controller(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuotaList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_resource_quota(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ResourceQuota - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ResourceQuotaList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_resource_quota(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_resource_quota(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_resource_quota(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1SecretList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_secret(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Secret - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1SecretList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_secret(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_secret(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_secret(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_service(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Service - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ServiceList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_service(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_service(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_service(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccountList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_namespaced_service_account(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ServiceAccount - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ServiceAccountList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_namespaced_service_account(_api::CoreV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_service_account(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_namespaced_service_account(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1NodeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_node(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_node_CoreV1Api, "/api/v1/nodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Node - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1NodeList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_node(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_node(_api::CoreV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_persistent_volume(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PersistentVolume - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PersistentVolumeList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_persistent_volume(_api::CoreV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_persistent_volume(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_persistent_volume(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_persistent_volume_claim_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaimList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_persistent_volume_claim_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_persistent_volume_claim_for_all_namespaces_CoreV1Api, "/api/v1/persistentvolumeclaims", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PersistentVolumeClaim - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PersistentVolumeClaimList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_persistent_volume_claim_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_persistent_volume_claim_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_persistent_volume_claim_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_persistent_volume_claim_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_pod_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_pod_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_pod_for_all_namespaces_CoreV1Api, "/api/v1/pods", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Pod - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PodList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_pod_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_pod_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_pod_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_pod_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_pod_template_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplateList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_pod_template_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_pod_template_for_all_namespaces_CoreV1Api, "/api/v1/podtemplates", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodTemplate - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1PodTemplateList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_pod_template_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_pod_template_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_pod_template_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_pod_template_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_replication_controller_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationControllerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_replication_controller_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_replication_controller_for_all_namespaces_CoreV1Api, "/api/v1/replicationcontrollers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicationController - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ReplicationControllerList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_replication_controller_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_replication_controller_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_replication_controller_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_replication_controller_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_resource_quota_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuotaList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_resource_quota_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_resource_quota_for_all_namespaces_CoreV1Api, "/api/v1/resourcequotas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ResourceQuota - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ResourceQuotaList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_resource_quota_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_resource_quota_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_resource_quota_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_resource_quota_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_secret_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1SecretList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_secret_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_secret_for_all_namespaces_CoreV1Api, "/api/v1/secrets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Secret - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1SecretList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_secret_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_secret_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_secret_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_secret_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_service_account_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccountList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_service_account_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_service_account_for_all_namespaces_CoreV1Api, "/api/v1/serviceaccounts", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ServiceAccount - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ServiceAccountList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_service_account_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_service_account_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_service_account_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_service_account_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_core_v1_service_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_core_v1_service_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_core_v1_service_for_all_namespaces_CoreV1Api, "/api/v1/services", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Service - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiCoreV1ServiceList, OpenAPI.Clients.ApiResponse -""" -function list_core_v1_service_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_service_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_core_v1_service_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_core_v1_service_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespace(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespace_CoreV1Api, "/api/v1/namespaces/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Namespace - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespace(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespace(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespace(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespace_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespace_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespace_status_CoreV1Api, "/api/v1/namespaces/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Namespace - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespace_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespace_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespace_status(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespace_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ConfigMap - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ConfigMap, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_config_map(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_config_map(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Endpoints - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Endpoints, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_endpoints(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_endpoints(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Event, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified LimitRange - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1LimitRange, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_limit_range(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_limit_range(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_persistent_volume_claim(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_persistent_volume_claim(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_pod_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_pod_status_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_pod_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PodTemplate - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1PodTemplate, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod_template(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_pod_template(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_replication_controller_scale_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_replication_controller_scale_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_replication_controller_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_replication_controller_status_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_replication_controller_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_resource_quota(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_resource_quota(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_resource_quota_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_resource_quota_status_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_resource_quota_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_resource_quota_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Secret - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Secret, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_secret(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_secret(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ServiceAccount - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1ServiceAccount, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service_account(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service_account(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_namespaced_service_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_namespaced_service_status_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_namespaced_service_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_namespaced_service_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_node(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_node_CoreV1Api, "/api/v1/nodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Node - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_node(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_node(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_node_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_node_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_node_status_CoreV1Api, "/api/v1/nodes/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Node - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_node_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_node_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_node_status(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_node_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_persistent_volume(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PersistentVolume - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_persistent_volume(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_persistent_volume(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_persistent_volume(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_core_v1_persistent_volume_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_core_v1_persistent_volume_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_core_v1_persistent_volume_status_CoreV1Api, "/api/v1/persistentvolumes/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified PersistentVolume - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function patch_core_v1_persistent_volume_status(_api::CoreV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_persistent_volume_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_core_v1_persistent_volume_status(_api::CoreV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_core_v1_persistent_volume_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_component_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ComponentStatus, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_component_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_component_status_CoreV1Api, "/api/v1/componentstatuses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ComponentStatus - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiCoreV1ComponentStatus, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_component_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_component_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_component_status(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_component_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespace(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespace_CoreV1Api, "/api/v1/namespaces/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Namespace - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespace(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespace(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespace(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespace_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespace_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespace_status_CoreV1Api, "/api/v1/namespaces/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Namespace - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespace_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespace_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespace_status(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespace_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ConfigMap - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1ConfigMap, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_config_map(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_config_map(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Endpoints - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Endpoints, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_endpoints(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_endpoints(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Event, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_event(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_event(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified LimitRange - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1LimitRange, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_limit_range(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_limit_range(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_pod_log_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => String, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_pod_log(_api::CoreV1Api, name::String, namespace::String; container=nothing, follow=nothing, insecure_skip_t_l_s_verify_backend=nothing, limit_bytes=nothing, pretty=nothing, previous=nothing, since_seconds=nothing, tail_lines=nothing, timestamps=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_pod_log_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/log", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "container", container) # type String - OpenAPI.Clients.set_param(_ctx.query, "follow", follow) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "insecureSkipTLSVerifyBackend", insecure_skip_t_l_s_verify_backend) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "limitBytes", limit_bytes) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "previous", previous) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "sinceSeconds", since_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "tailLines", tail_lines) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "timestamps", timestamps) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["text/plain", "application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read log of the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- container::String -- follow::Bool -- insecure_skip_t_l_s_verify_backend::Bool -- limit_bytes::Int64 -- pretty::String -- previous::Bool -- since_seconds::Int64 -- tail_lines::Int64 -- timestamps::Bool - -Return: String, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_pod_log(_api::CoreV1Api, name::String, namespace::String; container=nothing, follow=nothing, insecure_skip_t_l_s_verify_backend=nothing, limit_bytes=nothing, pretty=nothing, previous=nothing, since_seconds=nothing, tail_lines=nothing, timestamps=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_log(_api, name, namespace; container=container, follow=follow, insecure_skip_t_l_s_verify_backend=insecure_skip_t_l_s_verify_backend, limit_bytes=limit_bytes, pretty=pretty, previous=previous, since_seconds=since_seconds, tail_lines=tail_lines, timestamps=timestamps, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_pod_log(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; container=nothing, follow=nothing, insecure_skip_t_l_s_verify_backend=nothing, limit_bytes=nothing, pretty=nothing, previous=nothing, since_seconds=nothing, tail_lines=nothing, timestamps=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_log(_api, name, namespace; container=container, follow=follow, insecure_skip_t_l_s_verify_backend=insecure_skip_t_l_s_verify_backend, limit_bytes=limit_bytes, pretty=pretty, previous=previous, since_seconds=since_seconds, tail_lines=tail_lines, timestamps=timestamps, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_pod_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_pod_status_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_pod_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodTemplate - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1PodTemplate, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_template(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_pod_template(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_replication_controller_scale_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_replication_controller_scale_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_replication_controller_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_replication_controller_status_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_replication_controller_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_resource_quota(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_resource_quota(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_resource_quota_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_resource_quota_status_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_resource_quota_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_resource_quota_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Secret - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Secret, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_secret(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_secret(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ServiceAccount - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1ServiceAccount, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service_account(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service_account(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_namespaced_service_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_namespaced_service_status_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_namespaced_service_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_namespaced_service_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_node(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_node_CoreV1Api, "/api/v1/nodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Node - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_node(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_node(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_node_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_node_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_node_status_CoreV1Api, "/api/v1/nodes/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Node - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_node_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_node_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_node_status(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_node_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_persistent_volume(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PersistentVolume - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_persistent_volume(_api::CoreV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_persistent_volume(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_persistent_volume(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_core_v1_persistent_volume_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_core_v1_persistent_volume_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_core_v1_persistent_volume_status_CoreV1Api, "/api/v1/persistentvolumes/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified PersistentVolume - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function read_core_v1_persistent_volume_status(_api::CoreV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_persistent_volume_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_core_v1_persistent_volume_status(_api::CoreV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_core_v1_persistent_volume_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespace(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespace_CoreV1Api, "/api/v1/namespaces/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Namespace - -Params: -- name::String (required) -- body::IoK8sApiCoreV1Namespace (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespace(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespace_finalize_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespace_finalize(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespace_finalize_CoreV1Api, "/api/v1/namespaces/{name}/finalize", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace finalize of the specified Namespace - -Params: -- name::String (required) -- body::IoK8sApiCoreV1Namespace (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespace_finalize(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace_finalize(_api, name, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespace_finalize(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1Namespace; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace_finalize(_api, name, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespace_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Namespace, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespace_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespace_status_CoreV1Api, "/api/v1/namespaces/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Namespace - -Params: -- name::String (required) -- body::IoK8sApiCoreV1Namespace (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Namespace, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespace_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespace_status(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1Namespace; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespace_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ConfigMap, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/namespaces/{namespace}/configmaps/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ConfigMap - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ConfigMap (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ConfigMap, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_config_map(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_config_map(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Endpoints, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/namespaces/{namespace}/endpoints/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Endpoints - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Endpoints (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Endpoints, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_endpoints(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Endpoints; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_endpoints(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_event_CoreV1Api, "/api/v1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Event (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Event, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1LimitRange, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/namespaces/{namespace}/limitranges/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified LimitRange - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1LimitRange (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1LimitRange, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_limit_range(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1LimitRange; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_limit_range(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1PersistentVolumeClaim (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_persistent_volume_claim(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_persistent_volume_claim(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolumeClaim, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_persistent_volume_claim_status_CoreV1Api, "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified PersistentVolumeClaim - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1PersistentVolumeClaim (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolumeClaim, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_persistent_volume_claim_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_persistent_volume_claim_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_pod_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Pod (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_pod_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Pod, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_pod_status_CoreV1Api, "/api/v1/namespaces/{namespace}/pods/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Pod - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Pod (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Pod, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_pod_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_pod_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Pod; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PodTemplate, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/namespaces/{namespace}/podtemplates/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PodTemplate - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1PodTemplate (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PodTemplate, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod_template(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_pod_template(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ReplicationController (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_replication_controller_scale_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiAutoscalingV1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_replication_controller_scale_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiAutoscalingV1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiAutoscalingV1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_replication_controller_scale(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiAutoscalingV1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_replication_controller_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ReplicationController, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_replication_controller_status_CoreV1Api, "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified ReplicationController - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ReplicationController (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ReplicationController, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_replication_controller_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_replication_controller_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ResourceQuota (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_resource_quota(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_resource_quota(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_resource_quota_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ResourceQuota, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_resource_quota_status_CoreV1Api, "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified ResourceQuota - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ResourceQuota (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ResourceQuota, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_resource_quota_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_resource_quota_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_resource_quota_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Secret, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_secret_CoreV1Api, "/api/v1/namespaces/{namespace}/secrets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Secret - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Secret (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Secret, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_secret(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Secret; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_secret(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_service_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Service (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1ServiceAccount, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ServiceAccount - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1ServiceAccount (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1ServiceAccount, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service_account(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service_account(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_namespaced_service_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Service, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_namespaced_service_status_CoreV1Api, "/api/v1/namespaces/{namespace}/services/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Service - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiCoreV1Service (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Service, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_namespaced_service_status(_api::CoreV1Api, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_namespaced_service_status(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiCoreV1Service; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_namespaced_service_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_node(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_node_CoreV1Api, "/api/v1/nodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Node - -Params: -- name::String (required) -- body::IoK8sApiCoreV1Node (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_node(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_node(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_node_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1Node, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_node_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_node_status_CoreV1Api, "/api/v1/nodes/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Node - -Params: -- name::String (required) -- body::IoK8sApiCoreV1Node (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1Node, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_node_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_node_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_node_status(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1Node; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_node_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_persistent_volume(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_persistent_volume_CoreV1Api, "/api/v1/persistentvolumes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PersistentVolume - -Params: -- name::String (required) -- body::IoK8sApiCoreV1PersistentVolume (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_persistent_volume(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_persistent_volume(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_persistent_volume(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_core_v1_persistent_volume_status_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiCoreV1PersistentVolume, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_core_v1_persistent_volume_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_core_v1_persistent_volume_status_CoreV1Api, "/api/v1/persistentvolumes/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified PersistentVolume - -Params: -- name::String (required) -- body::IoK8sApiCoreV1PersistentVolume (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiCoreV1PersistentVolume, OpenAPI.Clients.ApiResponse -""" -function replace_core_v1_persistent_volume_status(_api::CoreV1Api, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_persistent_volume_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_core_v1_persistent_volume_status(_api::CoreV1Api, response_stream::Channel, name::String, body::IoK8sApiCoreV1PersistentVolume; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_core_v1_persistent_volume_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_config_map_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_config_map_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_config_map_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/configmaps", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_config_map_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_config_map_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_config_map_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_config_map_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_endpoints_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_endpoints_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_endpoints_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/endpoints", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_endpoints_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_endpoints_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_endpoints_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_endpoints_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_event_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_event_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_event_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_event_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_event_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_event_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_event_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_limit_range_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_limit_range_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_limit_range_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/limitranges", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_limit_range_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_limit_range_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_limit_range_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_limit_range_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespace_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespace(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespace_CoreV1Api, "/api/v1/watch/namespaces/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespace(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespace(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespace(_api::CoreV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespace(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespace_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespace_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespace_list_CoreV1Api, "/api/v1/watch/namespaces", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespace_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespace_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespace_list(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespace_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_config_map_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_config_map_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/configmaps/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_config_map(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_config_map(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_config_map(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_config_map(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_config_map_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_config_map_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_config_map_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/configmaps", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_config_map_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_config_map_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_config_map_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_config_map_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_endpoints_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_endpoints_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/endpoints/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_endpoints(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_endpoints(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_endpoints(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_endpoints(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_endpoints_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_endpoints_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_endpoints_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/endpoints", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_endpoints_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_endpoints_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_endpoints_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_endpoints_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_event_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_event_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/events/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_event(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_event(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_event(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_event(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_event_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_event_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_event_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_event_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_event_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_event_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_event_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_limit_range_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_limit_range_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/limitranges/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_limit_range(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_limit_range(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_limit_range(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_limit_range(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_limit_range_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_limit_range_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_limit_range_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/limitranges", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_limit_range_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_limit_range_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_limit_range_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_limit_range_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_persistent_volume_claim_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_persistent_volume_claim_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_persistent_volume_claim(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_persistent_volume_claim(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_persistent_volume_claim_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_persistent_volume_claim_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_persistent_volume_claim_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_persistent_volume_claim_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_persistent_volume_claim_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_persistent_volume_claim_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_persistent_volume_claim_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_pod_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_pod_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/pods/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_pod(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_pod(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_pod_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_pod_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_pod_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/pods", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_pod_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_pod_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_pod_template_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_pod_template_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/podtemplates/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_pod_template(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_template(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_pod_template(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_template(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_pod_template_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_pod_template_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_pod_template_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/podtemplates", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_pod_template_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_template_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_pod_template_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_pod_template_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_replication_controller_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_replication_controller_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_replication_controller(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_replication_controller(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_replication_controller(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_replication_controller(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_replication_controller_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_replication_controller_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_replication_controller_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/replicationcontrollers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_replication_controller_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_replication_controller_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_replication_controller_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_replication_controller_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_resource_quota_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_resource_quota_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_resource_quota(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_resource_quota(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_resource_quota(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_resource_quota(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_resource_quota_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_resource_quota_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_resource_quota_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/resourcequotas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_resource_quota_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_resource_quota_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_resource_quota_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_resource_quota_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_secret_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_secret_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/secrets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_secret(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_secret(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_secret(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_secret(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_secret_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_secret_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_secret_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/secrets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_secret_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_secret_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_secret_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_secret_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_service_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_service_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/services/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_service(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_service(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_service_account_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_service_account_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_service_account(_api::CoreV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_account(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_service_account(_api::CoreV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_account(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_service_account_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_service_account_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_service_account_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/serviceaccounts", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_service_account_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_account_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_service_account_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_account_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_namespaced_service_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_namespaced_service_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_namespaced_service_list_CoreV1Api, "/api/v1/watch/namespaces/{namespace}/services", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_namespaced_service_list(_api::CoreV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_namespaced_service_list(_api::CoreV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_namespaced_service_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_node_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_node(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_node_CoreV1Api, "/api/v1/watch/nodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_node(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_node(_api::CoreV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_node_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_node_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_node_list_CoreV1Api, "/api/v1/watch/nodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_node_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_node_list(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_persistent_volume_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_persistent_volume(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_persistent_volume_CoreV1Api, "/api/v1/watch/persistentvolumes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_persistent_volume(_api::CoreV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_persistent_volume(_api::CoreV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_persistent_volume_claim_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_persistent_volume_claim_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/persistentvolumeclaims", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_persistent_volume_list_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_persistent_volume_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_persistent_volume_list_CoreV1Api, "/api/v1/watch/persistentvolumes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_persistent_volume_list(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_persistent_volume_list(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_persistent_volume_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_pod_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_pod_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_pod_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/pods", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_pod_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_pod_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_pod_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_pod_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_pod_template_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_pod_template_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_pod_template_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/podtemplates", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_pod_template_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_pod_template_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_pod_template_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_pod_template_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_replication_controller_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_replication_controller_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_replication_controller_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/replicationcontrollers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_replication_controller_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_replication_controller_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_replication_controller_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_replication_controller_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_resource_quota_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_resource_quota_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_resource_quota_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/resourcequotas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_resource_quota_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_resource_quota_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_resource_quota_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_resource_quota_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_secret_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_secret_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_secret_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/secrets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_secret_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_secret_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_secret_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_secret_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_service_account_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_service_account_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_service_account_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/serviceaccounts", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_service_account_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_service_account_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_service_account_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_service_account_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_core_v1_service_list_for_all_namespaces_CoreV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_core_v1_service_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_core_v1_service_list_for_all_namespaces_CoreV1Api, "/api/v1/watch/services", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_core_v1_service_list_for_all_namespaces(_api::CoreV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_service_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_core_v1_service_list_for_all_namespaces(_api::CoreV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_core_v1_service_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export connect_core_v1_delete_namespaced_pod_proxy -export connect_core_v1_delete_namespaced_pod_proxy_with_path -export connect_core_v1_delete_namespaced_service_proxy -export connect_core_v1_delete_namespaced_service_proxy_with_path -export connect_core_v1_delete_node_proxy -export connect_core_v1_delete_node_proxy_with_path -export connect_core_v1_get_namespaced_pod_attach -export connect_core_v1_get_namespaced_pod_exec -export connect_core_v1_get_namespaced_pod_portforward -export connect_core_v1_get_namespaced_pod_proxy -export connect_core_v1_get_namespaced_pod_proxy_with_path -export connect_core_v1_get_namespaced_service_proxy -export connect_core_v1_get_namespaced_service_proxy_with_path -export connect_core_v1_get_node_proxy -export connect_core_v1_get_node_proxy_with_path -export connect_core_v1_head_namespaced_pod_proxy -export connect_core_v1_head_namespaced_pod_proxy_with_path -export connect_core_v1_head_namespaced_service_proxy -export connect_core_v1_head_namespaced_service_proxy_with_path -export connect_core_v1_head_node_proxy -export connect_core_v1_head_node_proxy_with_path -export connect_core_v1_options_namespaced_pod_proxy -export connect_core_v1_options_namespaced_pod_proxy_with_path -export connect_core_v1_options_namespaced_service_proxy -export connect_core_v1_options_namespaced_service_proxy_with_path -export connect_core_v1_options_node_proxy -export connect_core_v1_options_node_proxy_with_path -export connect_core_v1_patch_namespaced_pod_proxy -export connect_core_v1_patch_namespaced_pod_proxy_with_path -export connect_core_v1_patch_namespaced_service_proxy -export connect_core_v1_patch_namespaced_service_proxy_with_path -export connect_core_v1_patch_node_proxy -export connect_core_v1_patch_node_proxy_with_path -export connect_core_v1_post_namespaced_pod_attach -export connect_core_v1_post_namespaced_pod_exec -export connect_core_v1_post_namespaced_pod_portforward -export connect_core_v1_post_namespaced_pod_proxy -export connect_core_v1_post_namespaced_pod_proxy_with_path -export connect_core_v1_post_namespaced_service_proxy -export connect_core_v1_post_namespaced_service_proxy_with_path -export connect_core_v1_post_node_proxy -export connect_core_v1_post_node_proxy_with_path -export connect_core_v1_put_namespaced_pod_proxy -export connect_core_v1_put_namespaced_pod_proxy_with_path -export connect_core_v1_put_namespaced_service_proxy -export connect_core_v1_put_namespaced_service_proxy_with_path -export connect_core_v1_put_node_proxy -export connect_core_v1_put_node_proxy_with_path -export create_core_v1_namespace -export create_core_v1_namespaced_binding -export create_core_v1_namespaced_config_map -export create_core_v1_namespaced_endpoints -export create_core_v1_namespaced_event -export create_core_v1_namespaced_limit_range -export create_core_v1_namespaced_persistent_volume_claim -export create_core_v1_namespaced_pod -export create_core_v1_namespaced_pod_binding -export create_core_v1_namespaced_pod_eviction -export create_core_v1_namespaced_pod_template -export create_core_v1_namespaced_replication_controller -export create_core_v1_namespaced_resource_quota -export create_core_v1_namespaced_secret -export create_core_v1_namespaced_service -export create_core_v1_namespaced_service_account -export create_core_v1_namespaced_service_account_token -export create_core_v1_node -export create_core_v1_persistent_volume -export delete_core_v1_collection_namespaced_config_map -export delete_core_v1_collection_namespaced_endpoints -export delete_core_v1_collection_namespaced_event -export delete_core_v1_collection_namespaced_limit_range -export delete_core_v1_collection_namespaced_persistent_volume_claim -export delete_core_v1_collection_namespaced_pod -export delete_core_v1_collection_namespaced_pod_template -export delete_core_v1_collection_namespaced_replication_controller -export delete_core_v1_collection_namespaced_resource_quota -export delete_core_v1_collection_namespaced_secret -export delete_core_v1_collection_namespaced_service_account -export delete_core_v1_collection_node -export delete_core_v1_collection_persistent_volume -export delete_core_v1_namespace -export delete_core_v1_namespaced_config_map -export delete_core_v1_namespaced_endpoints -export delete_core_v1_namespaced_event -export delete_core_v1_namespaced_limit_range -export delete_core_v1_namespaced_persistent_volume_claim -export delete_core_v1_namespaced_pod -export delete_core_v1_namespaced_pod_template -export delete_core_v1_namespaced_replication_controller -export delete_core_v1_namespaced_resource_quota -export delete_core_v1_namespaced_secret -export delete_core_v1_namespaced_service -export delete_core_v1_namespaced_service_account -export delete_core_v1_node -export delete_core_v1_persistent_volume -export get_core_v1_a_p_i_resources -export list_core_v1_component_status -export list_core_v1_config_map_for_all_namespaces -export list_core_v1_endpoints_for_all_namespaces -export list_core_v1_event_for_all_namespaces -export list_core_v1_limit_range_for_all_namespaces -export list_core_v1_namespace -export list_core_v1_namespaced_config_map -export list_core_v1_namespaced_endpoints -export list_core_v1_namespaced_event -export list_core_v1_namespaced_limit_range -export list_core_v1_namespaced_persistent_volume_claim -export list_core_v1_namespaced_pod -export list_core_v1_namespaced_pod_template -export list_core_v1_namespaced_replication_controller -export list_core_v1_namespaced_resource_quota -export list_core_v1_namespaced_secret -export list_core_v1_namespaced_service -export list_core_v1_namespaced_service_account -export list_core_v1_node -export list_core_v1_persistent_volume -export list_core_v1_persistent_volume_claim_for_all_namespaces -export list_core_v1_pod_for_all_namespaces -export list_core_v1_pod_template_for_all_namespaces -export list_core_v1_replication_controller_for_all_namespaces -export list_core_v1_resource_quota_for_all_namespaces -export list_core_v1_secret_for_all_namespaces -export list_core_v1_service_account_for_all_namespaces -export list_core_v1_service_for_all_namespaces -export patch_core_v1_namespace -export patch_core_v1_namespace_status -export patch_core_v1_namespaced_config_map -export patch_core_v1_namespaced_endpoints -export patch_core_v1_namespaced_event -export patch_core_v1_namespaced_limit_range -export patch_core_v1_namespaced_persistent_volume_claim -export patch_core_v1_namespaced_persistent_volume_claim_status -export patch_core_v1_namespaced_pod -export patch_core_v1_namespaced_pod_status -export patch_core_v1_namespaced_pod_template -export patch_core_v1_namespaced_replication_controller -export patch_core_v1_namespaced_replication_controller_scale -export patch_core_v1_namespaced_replication_controller_status -export patch_core_v1_namespaced_resource_quota -export patch_core_v1_namespaced_resource_quota_status -export patch_core_v1_namespaced_secret -export patch_core_v1_namespaced_service -export patch_core_v1_namespaced_service_account -export patch_core_v1_namespaced_service_status -export patch_core_v1_node -export patch_core_v1_node_status -export patch_core_v1_persistent_volume -export patch_core_v1_persistent_volume_status -export read_core_v1_component_status -export read_core_v1_namespace -export read_core_v1_namespace_status -export read_core_v1_namespaced_config_map -export read_core_v1_namespaced_endpoints -export read_core_v1_namespaced_event -export read_core_v1_namespaced_limit_range -export read_core_v1_namespaced_persistent_volume_claim -export read_core_v1_namespaced_persistent_volume_claim_status -export read_core_v1_namespaced_pod -export read_core_v1_namespaced_pod_log -export read_core_v1_namespaced_pod_status -export read_core_v1_namespaced_pod_template -export read_core_v1_namespaced_replication_controller -export read_core_v1_namespaced_replication_controller_scale -export read_core_v1_namespaced_replication_controller_status -export read_core_v1_namespaced_resource_quota -export read_core_v1_namespaced_resource_quota_status -export read_core_v1_namespaced_secret -export read_core_v1_namespaced_service -export read_core_v1_namespaced_service_account -export read_core_v1_namespaced_service_status -export read_core_v1_node -export read_core_v1_node_status -export read_core_v1_persistent_volume -export read_core_v1_persistent_volume_status -export replace_core_v1_namespace -export replace_core_v1_namespace_finalize -export replace_core_v1_namespace_status -export replace_core_v1_namespaced_config_map -export replace_core_v1_namespaced_endpoints -export replace_core_v1_namespaced_event -export replace_core_v1_namespaced_limit_range -export replace_core_v1_namespaced_persistent_volume_claim -export replace_core_v1_namespaced_persistent_volume_claim_status -export replace_core_v1_namespaced_pod -export replace_core_v1_namespaced_pod_status -export replace_core_v1_namespaced_pod_template -export replace_core_v1_namespaced_replication_controller -export replace_core_v1_namespaced_replication_controller_scale -export replace_core_v1_namespaced_replication_controller_status -export replace_core_v1_namespaced_resource_quota -export replace_core_v1_namespaced_resource_quota_status -export replace_core_v1_namespaced_secret -export replace_core_v1_namespaced_service -export replace_core_v1_namespaced_service_account -export replace_core_v1_namespaced_service_status -export replace_core_v1_node -export replace_core_v1_node_status -export replace_core_v1_persistent_volume -export replace_core_v1_persistent_volume_status -export watch_core_v1_config_map_list_for_all_namespaces -export watch_core_v1_endpoints_list_for_all_namespaces -export watch_core_v1_event_list_for_all_namespaces -export watch_core_v1_limit_range_list_for_all_namespaces -export watch_core_v1_namespace -export watch_core_v1_namespace_list -export watch_core_v1_namespaced_config_map -export watch_core_v1_namespaced_config_map_list -export watch_core_v1_namespaced_endpoints -export watch_core_v1_namespaced_endpoints_list -export watch_core_v1_namespaced_event -export watch_core_v1_namespaced_event_list -export watch_core_v1_namespaced_limit_range -export watch_core_v1_namespaced_limit_range_list -export watch_core_v1_namespaced_persistent_volume_claim -export watch_core_v1_namespaced_persistent_volume_claim_list -export watch_core_v1_namespaced_pod -export watch_core_v1_namespaced_pod_list -export watch_core_v1_namespaced_pod_template -export watch_core_v1_namespaced_pod_template_list -export watch_core_v1_namespaced_replication_controller -export watch_core_v1_namespaced_replication_controller_list -export watch_core_v1_namespaced_resource_quota -export watch_core_v1_namespaced_resource_quota_list -export watch_core_v1_namespaced_secret -export watch_core_v1_namespaced_secret_list -export watch_core_v1_namespaced_service -export watch_core_v1_namespaced_service_account -export watch_core_v1_namespaced_service_account_list -export watch_core_v1_namespaced_service_list -export watch_core_v1_node -export watch_core_v1_node_list -export watch_core_v1_persistent_volume -export watch_core_v1_persistent_volume_claim_list_for_all_namespaces -export watch_core_v1_persistent_volume_list -export watch_core_v1_pod_list_for_all_namespaces -export watch_core_v1_pod_template_list_for_all_namespaces -export watch_core_v1_replication_controller_list_for_all_namespaces -export watch_core_v1_resource_quota_list_for_all_namespaces -export watch_core_v1_secret_list_for_all_namespaces -export watch_core_v1_service_account_list_for_all_namespaces -export watch_core_v1_service_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_CustomMetricsV1beta1Api.jl b/src/ApiImpl/api/apis/api_CustomMetricsV1beta1Api.jl deleted file mode 100644 index 4e976f20..00000000 --- a/src/ApiImpl/api/apis/api_CustomMetricsV1beta1Api.jl +++ /dev/null @@ -1,93 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct CustomMetricsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `CustomMetricsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ CustomMetricsV1beta1Api }) = "http://localhost" - -const _returntypes_list_custom_metrics_v1beta1_metric_value_CustomMetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCustomMetricsV1beta1MetricValueList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_custom_metrics_v1beta1_metric_value(_api::CustomMetricsV1beta1Api, compositemetricname::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_custom_metrics_v1beta1_metric_value_CustomMetricsV1beta1Api, "/apis/custom.metrics.k8s.io/v1beta1/{compositemetricname}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "compositemetricname", compositemetricname) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""Retrieve the given metric for the given non-namespaced object (e.g. Node, PersistentVolume). Composite metric name is of the form \"//\" Passing '*' for objectname would retrieve the given metric for all non-namespaced objects of the given type. - -Params: -- compositemetricname::String (required) -- pretty::String -- field_selector::String -- label_selector::String -- limit::Int64 - -Return: IoK8sApiCustomMetricsV1beta1MetricValueList, OpenAPI.Clients.ApiResponse -""" -function list_custom_metrics_v1beta1_metric_value(_api::CustomMetricsV1beta1Api, compositemetricname::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_custom_metrics_v1beta1_metric_value(_api, compositemetricname; pretty=pretty, field_selector=field_selector, label_selector=label_selector, limit=limit, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_custom_metrics_v1beta1_metric_value(_api::CustomMetricsV1beta1Api, response_stream::Channel, compositemetricname::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_custom_metrics_v1beta1_metric_value(_api, compositemetricname; pretty=pretty, field_selector=field_selector, label_selector=label_selector, limit=limit, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_custom_metrics_v1beta1_namespaced_metric_value_CustomMetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiCustomMetricsV1beta1MetricValueList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_custom_metrics_v1beta1_namespaced_metric_value(_api::CustomMetricsV1beta1Api, compositemetricname::String, namespace::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_custom_metrics_v1beta1_namespaced_metric_value_CustomMetricsV1beta1Api, "/apis/custom.metrics.k8s.io/v1beta1/namespaces/{namespace}/{compositemetricname}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "compositemetricname", compositemetricname) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""retrieve the given metric (in composite form) which describes the given namespace. Composite form of metrics can be either \"metric/\" to fetch metrics of all objects in the namespace, or \"//\" to fetch metrics of the specified object type and name. Passing \"*\" for objectname would fetch metrics of all objects of the specified type in the namespace. - -Params: -- compositemetricname::String (required) -- namespace::String (required) -- pretty::String -- field_selector::String -- label_selector::String -- limit::Int64 - -Return: IoK8sApiCustomMetricsV1beta1MetricValueList, OpenAPI.Clients.ApiResponse -""" -function list_custom_metrics_v1beta1_namespaced_metric_value(_api::CustomMetricsV1beta1Api, compositemetricname::String, namespace::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_custom_metrics_v1beta1_namespaced_metric_value(_api, compositemetricname, namespace; pretty=pretty, field_selector=field_selector, label_selector=label_selector, limit=limit, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_custom_metrics_v1beta1_namespaced_metric_value(_api::CustomMetricsV1beta1Api, response_stream::Channel, compositemetricname::String, namespace::String; pretty=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_custom_metrics_v1beta1_namespaced_metric_value(_api, compositemetricname, namespace; pretty=pretty, field_selector=field_selector, label_selector=label_selector, limit=limit, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export list_custom_metrics_v1beta1_metric_value -export list_custom_metrics_v1beta1_namespaced_metric_value diff --git a/src/ApiImpl/api/apis/api_DiscoveryApi.jl b/src/ApiImpl/api/apis/api_DiscoveryApi.jl deleted file mode 100644 index 867c13c7..00000000 --- a/src/ApiImpl/api/apis/api_DiscoveryApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct DiscoveryApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `DiscoveryApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ DiscoveryApi }) = "http://localhost" - -const _returntypes_get_discovery_a_p_i_group_DiscoveryApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_discovery_a_p_i_group(_api::DiscoveryApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_discovery_a_p_i_group_DiscoveryApi, "/apis/discovery.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_discovery_a_p_i_group(_api::DiscoveryApi; _mediaType=nothing) - _ctx = _oacinternal_get_discovery_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_discovery_a_p_i_group(_api::DiscoveryApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_discovery_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_discovery_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_DiscoveryV1beta1Api.jl b/src/ApiImpl/api/apis/api_DiscoveryV1beta1Api.jl deleted file mode 100644 index 432923db..00000000 --- a/src/ApiImpl/api/apis/api_DiscoveryV1beta1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct DiscoveryV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `DiscoveryV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ DiscoveryV1beta1Api }) = "http://localhost" - -const _returntypes_create_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an EndpointSlice - -Params: -- namespace::String (required) -- body::IoK8sApiDiscoveryV1beta1EndpointSlice (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiDiscoveryV1beta1EndpointSlice, OpenAPI.Clients.ApiResponse -""" -function create_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_discovery_v1beta1_namespaced_endpoint_slice(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_discovery_v1beta1_namespaced_endpoint_slice(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_discovery_v1beta1_collection_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_discovery_v1beta1_collection_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of EndpointSlice - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an EndpointSlice - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_discovery_v1beta1_a_p_i_resources_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_discovery_v1beta1_a_p_i_resources(_api::DiscoveryV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_discovery_v1beta1_a_p_i_resources_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_discovery_v1beta1_a_p_i_resources(_api::DiscoveryV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_discovery_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_discovery_v1beta1_a_p_i_resources(_api::DiscoveryV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_discovery_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_discovery_v1beta1_endpoint_slice_for_all_namespaces_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSliceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api::DiscoveryV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_discovery_v1beta1_endpoint_slice_for_all_namespaces_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/endpointslices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind EndpointSlice - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiDiscoveryV1beta1EndpointSliceList, OpenAPI.Clients.ApiResponse -""" -function list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api::DiscoveryV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api::DiscoveryV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSliceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind EndpointSlice - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiDiscoveryV1beta1EndpointSliceList, OpenAPI.Clients.ApiResponse -""" -function list_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_discovery_v1beta1_namespaced_endpoint_slice(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_discovery_v1beta1_namespaced_endpoint_slice(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified EndpointSlice - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiDiscoveryV1beta1EndpointSlice, OpenAPI.Clients.ApiResponse -""" -function patch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified EndpointSlice - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiDiscoveryV1beta1EndpointSlice, OpenAPI.Clients.ApiResponse -""" -function read_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiDiscoveryV1beta1EndpointSlice, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified EndpointSlice - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiDiscoveryV1beta1EndpointSlice (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiDiscoveryV1beta1EndpointSlice, OpenAPI.Clients.ApiResponse -""" -function replace_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiDiscoveryV1beta1EndpointSlice; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api::DiscoveryV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/watch/endpointslices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api::DiscoveryV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api::DiscoveryV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_discovery_v1beta1_namespaced_endpoint_slice_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/watch/namespaces/{namespace}/endpointslices/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_discovery_v1beta1_namespaced_endpoint_slice(_api::DiscoveryV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_discovery_v1beta1_namespaced_endpoint_slice_list_DiscoveryV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api::DiscoveryV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_discovery_v1beta1_namespaced_endpoint_slice_list_DiscoveryV1beta1Api, "/apis/discovery.k8s.io/v1beta1/watch/namespaces/{namespace}/endpointslices", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api::DiscoveryV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api::DiscoveryV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_discovery_v1beta1_namespaced_endpoint_slice -export delete_discovery_v1beta1_collection_namespaced_endpoint_slice -export delete_discovery_v1beta1_namespaced_endpoint_slice -export get_discovery_v1beta1_a_p_i_resources -export list_discovery_v1beta1_endpoint_slice_for_all_namespaces -export list_discovery_v1beta1_namespaced_endpoint_slice -export patch_discovery_v1beta1_namespaced_endpoint_slice -export read_discovery_v1beta1_namespaced_endpoint_slice -export replace_discovery_v1beta1_namespaced_endpoint_slice -export watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces -export watch_discovery_v1beta1_namespaced_endpoint_slice -export watch_discovery_v1beta1_namespaced_endpoint_slice_list diff --git a/src/ApiImpl/api/apis/api_EventsApi.jl b/src/ApiImpl/api/apis/api_EventsApi.jl deleted file mode 100644 index c14266a9..00000000 --- a/src/ApiImpl/api/apis/api_EventsApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct EventsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `EventsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ EventsApi }) = "http://localhost" - -const _returntypes_get_events_a_p_i_group_EventsApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_events_a_p_i_group(_api::EventsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_events_a_p_i_group_EventsApi, "/apis/events.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_events_a_p_i_group(_api::EventsApi; _mediaType=nothing) - _ctx = _oacinternal_get_events_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_events_a_p_i_group(_api::EventsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_events_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_events_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_EventsV1beta1Api.jl b/src/ApiImpl/api/apis/api_EventsV1beta1Api.jl deleted file mode 100644 index 51763f6c..00000000 --- a/src/ApiImpl/api/apis/api_EventsV1beta1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct EventsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `EventsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ EventsV1beta1Api }) = "http://localhost" - -const _returntypes_create_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an Event - -Params: -- namespace::String (required) -- body::IoK8sApiEventsV1beta1Event (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiEventsV1beta1Event, OpenAPI.Clients.ApiResponse -""" -function create_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_events_v1beta1_namespaced_event(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_events_v1beta1_namespaced_event(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_events_v1beta1_collection_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_events_v1beta1_collection_namespaced_event(_api::EventsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_events_v1beta1_collection_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Event - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_events_v1beta1_collection_namespaced_event(_api::EventsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_events_v1beta1_collection_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_events_v1beta1_collection_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_events_v1beta1_collection_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an Event - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_events_v1beta1_namespaced_event(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_events_v1beta1_namespaced_event(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_events_v1beta1_a_p_i_resources_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_events_v1beta1_a_p_i_resources(_api::EventsV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_events_v1beta1_a_p_i_resources_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_events_v1beta1_a_p_i_resources(_api::EventsV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_events_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_events_v1beta1_a_p_i_resources(_api::EventsV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_events_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_events_v1beta1_event_for_all_namespaces_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1EventList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_events_v1beta1_event_for_all_namespaces(_api::EventsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_events_v1beta1_event_for_all_namespaces_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Event - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiEventsV1beta1EventList, OpenAPI.Clients.ApiResponse -""" -function list_events_v1beta1_event_for_all_namespaces(_api::EventsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_events_v1beta1_event_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_events_v1beta1_event_for_all_namespaces(_api::EventsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_events_v1beta1_event_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1EventList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Event - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiEventsV1beta1EventList, OpenAPI.Clients.ApiResponse -""" -function list_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_events_v1beta1_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_events_v1beta1_namespaced_event(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiEventsV1beta1Event, OpenAPI.Clients.ApiResponse -""" -function patch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_events_v1beta1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_events_v1beta1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiEventsV1beta1Event, OpenAPI.Clients.ApiResponse -""" -function read_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_events_v1beta1_namespaced_event(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_events_v1beta1_namespaced_event(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiEventsV1beta1Event, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Event - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiEventsV1beta1Event (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiEventsV1beta1Event, OpenAPI.Clients.ApiResponse -""" -function replace_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_events_v1beta1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiEventsV1beta1Event; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_events_v1beta1_namespaced_event(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_events_v1beta1_event_list_for_all_namespaces_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_events_v1beta1_event_list_for_all_namespaces(_api::EventsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_events_v1beta1_event_list_for_all_namespaces_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/watch/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_events_v1beta1_event_list_for_all_namespaces(_api::EventsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_event_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_events_v1beta1_event_list_for_all_namespaces(_api::EventsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_event_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_events_v1beta1_namespaced_event_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_events_v1beta1_namespaced_event_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/watch/namespaces/{namespace}/events/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_namespaced_event(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_events_v1beta1_namespaced_event(_api::EventsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_namespaced_event(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_events_v1beta1_namespaced_event_list_EventsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_events_v1beta1_namespaced_event_list(_api::EventsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_events_v1beta1_namespaced_event_list_EventsV1beta1Api, "/apis/events.k8s.io/v1beta1/watch/namespaces/{namespace}/events", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_events_v1beta1_namespaced_event_list(_api::EventsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_namespaced_event_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_events_v1beta1_namespaced_event_list(_api::EventsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_events_v1beta1_namespaced_event_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_events_v1beta1_namespaced_event -export delete_events_v1beta1_collection_namespaced_event -export delete_events_v1beta1_namespaced_event -export get_events_v1beta1_a_p_i_resources -export list_events_v1beta1_event_for_all_namespaces -export list_events_v1beta1_namespaced_event -export patch_events_v1beta1_namespaced_event -export read_events_v1beta1_namespaced_event -export replace_events_v1beta1_namespaced_event -export watch_events_v1beta1_event_list_for_all_namespaces -export watch_events_v1beta1_namespaced_event -export watch_events_v1beta1_namespaced_event_list diff --git a/src/ApiImpl/api/apis/api_ExtensionsApi.jl b/src/ApiImpl/api/apis/api_ExtensionsApi.jl deleted file mode 100644 index d590dee4..00000000 --- a/src/ApiImpl/api/apis/api_ExtensionsApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ExtensionsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ExtensionsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ExtensionsApi }) = "http://localhost" - -const _returntypes_get_extensions_a_p_i_group_ExtensionsApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_extensions_a_p_i_group(_api::ExtensionsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_extensions_a_p_i_group_ExtensionsApi, "/apis/extensions/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_extensions_a_p_i_group(_api::ExtensionsApi; _mediaType=nothing) - _ctx = _oacinternal_get_extensions_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_extensions_a_p_i_group(_api::ExtensionsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_extensions_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_extensions_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_ExtensionsV1beta1Api.jl b/src/ApiImpl/api/apis/api_ExtensionsV1beta1Api.jl deleted file mode 100644 index a325f523..00000000 --- a/src/ApiImpl/api/apis/api_ExtensionsV1beta1Api.jl +++ /dev/null @@ -1,3846 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct ExtensionsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `ExtensionsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ ExtensionsV1beta1Api }) = "http://localhost" - -const _returntypes_create_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a DaemonSet - -Params: -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_daemon_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Deployment - -Params: -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_deployment(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_namespaced_deployment_rollback_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_deployment_rollback(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_deployment_rollback_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/rollback", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create rollback of a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1DeploymentRollback (required) -- dry_run::String -- field_manager::String -- pretty::String - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_deployment_rollback(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_deployment_rollback(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_deployment_rollback(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DeploymentRollback; dry_run=nothing, field_manager=nothing, pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_deployment_rollback(_api, name, namespace, body; dry_run=dry_run, field_manager=field_manager, pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an Ingress - -Params: -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_ingress(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_ingress(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a NetworkPolicy - -Params: -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1NetworkPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_network_policy(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_network_policy(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ReplicaSet - -Params: -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_namespaced_replica_set(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PodSecurityPolicy - -Params: -- body::IoK8sApiExtensionsV1beta1PodSecurityPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function create_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_pod_security_policy(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_extensions_v1beta1_pod_security_policy(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Ingress - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of NetworkPolicy - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_collection_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_collection_pod_security_policy(_api::ExtensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_collection_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PodSecurityPolicy - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_collection_pod_security_policy(_api::ExtensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_collection_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_collection_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PodSecurityPolicy - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_pod_security_policy(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_extensions_v1beta1_pod_security_policy(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_extensions_v1beta1_a_p_i_resources_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_extensions_v1beta1_a_p_i_resources(_api::ExtensionsV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_extensions_v1beta1_a_p_i_resources_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_extensions_v1beta1_a_p_i_resources(_api::ExtensionsV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_extensions_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_extensions_v1beta1_a_p_i_resources(_api::ExtensionsV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_extensions_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_daemon_set_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_daemon_set_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_daemon_set_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_daemon_set_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_daemon_set_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_daemon_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_deployment_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_deployment_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_deployment_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_deployment_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_deployment_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_deployment_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_ingress_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1IngressList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_ingress_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_ingress_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Ingress - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1IngressList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_ingress_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_ingress_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_ingress_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_ingress_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind DaemonSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1DaemonSetList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_daemon_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DeploymentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Deployment - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1DeploymentList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_deployment(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1IngressList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Ingress - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1IngressList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind NetworkPolicy - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1NetworkPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_namespaced_replica_set(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_network_policy_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_network_policy_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_network_policy_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind NetworkPolicy - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1NetworkPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_network_policy_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_network_policy_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_network_policy_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_network_policy_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodSecurityPolicy - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1PodSecurityPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_extensions_v1beta1_replica_set_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_extensions_v1beta1_replica_set_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_extensions_v1beta1_replica_set_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ReplicaSet - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiExtensionsV1beta1ReplicaSetList, OpenAPI.Clients.ApiResponse -""" -function list_extensions_v1beta1_replica_set_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_extensions_v1beta1_replica_set_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_extensions_v1beta1_replica_set_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update scale of the specified ReplicationControllerDummy - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PodSecurityPolicy - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiExtensionsV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function patch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_extensions_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read scale of the specified ReplicationControllerDummy - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodSecurityPolicy - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiExtensionsV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function read_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_pod_security_policy(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_extensions_v1beta1_pod_security_policy(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1DaemonSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_daemon_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/daemonsets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified DaemonSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1DaemonSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1DaemonSet, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_daemon_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1DaemonSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_daemon_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_deployment_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_deployment_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Deployment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_deployment_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/deployments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Deployment - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Deployment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Deployment, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_deployment_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Deployment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_deployment_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_ingress_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_ingress_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1NetworkPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_replica_set_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_replica_set_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1ReplicaSet, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_replica_set_status_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicasets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified ReplicaSet - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1ReplicaSet (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1ReplicaSet, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_replica_set_status(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1ReplicaSet; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replica_set_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1Scale, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/namespaces/{namespace}/replicationcontrollers/{name}/scale", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace scale of the specified ReplicationControllerDummy - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiExtensionsV1beta1Scale (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1Scale, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiExtensionsV1beta1Scale; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiExtensionsV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PodSecurityPolicy - -Params: -- name::String (required) -- body::IoK8sApiExtensionsV1beta1PodSecurityPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiExtensionsV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function replace_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiExtensionsV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_extensions_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_daemon_set_list_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_daemon_set_list_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_deployment_list_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_deployment_list_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_ingress_list_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_ingress_list_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_daemon_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/daemonsets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_daemon_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_daemon_set_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_daemon_set_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/daemonsets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_daemon_set_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_daemon_set_list(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_daemon_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_deployment_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/deployments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_deployment(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_deployment(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_deployment_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_deployment_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_deployment_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/deployments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_deployment_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_deployment_list(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_deployment_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_ingress_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_ingress(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_ingress(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_ingress(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_ingress_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_ingress_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_ingress_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_ingress_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_ingress_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_ingress_list(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_ingress_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_network_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_network_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_network_policy(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_network_policy_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_network_policy_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_network_policy_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_network_policy_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_network_policy_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_network_policy_list(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_network_policy_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_replica_set_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/replicasets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_replica_set(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_replica_set(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_namespaced_replica_set_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_namespaced_replica_set_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_namespaced_replica_set_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/namespaces/{namespace}/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_namespaced_replica_set_list(_api::ExtensionsV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_namespaced_replica_set_list(_api::ExtensionsV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_namespaced_replica_set_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_network_policy_list_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_network_policy_list_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_pod_security_policy_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/podsecuritypolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_pod_security_policy(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_pod_security_policy(_api::ExtensionsV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_pod_security_policy(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_pod_security_policy_list_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_pod_security_policy_list(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_pod_security_policy_list_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/podsecuritypolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_pod_security_policy_list(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_pod_security_policy_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_pod_security_policy_list(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_pod_security_policy_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_extensions_v1beta1_replica_set_list_for_all_namespaces_ExtensionsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_extensions_v1beta1_replica_set_list_for_all_namespaces_ExtensionsV1beta1Api, "/apis/extensions/v1beta1/watch/replicasets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api::ExtensionsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_extensions_v1beta1_namespaced_daemon_set -export create_extensions_v1beta1_namespaced_deployment -export create_extensions_v1beta1_namespaced_deployment_rollback -export create_extensions_v1beta1_namespaced_ingress -export create_extensions_v1beta1_namespaced_network_policy -export create_extensions_v1beta1_namespaced_replica_set -export create_extensions_v1beta1_pod_security_policy -export delete_extensions_v1beta1_collection_namespaced_daemon_set -export delete_extensions_v1beta1_collection_namespaced_deployment -export delete_extensions_v1beta1_collection_namespaced_ingress -export delete_extensions_v1beta1_collection_namespaced_network_policy -export delete_extensions_v1beta1_collection_namespaced_replica_set -export delete_extensions_v1beta1_collection_pod_security_policy -export delete_extensions_v1beta1_namespaced_daemon_set -export delete_extensions_v1beta1_namespaced_deployment -export delete_extensions_v1beta1_namespaced_ingress -export delete_extensions_v1beta1_namespaced_network_policy -export delete_extensions_v1beta1_namespaced_replica_set -export delete_extensions_v1beta1_pod_security_policy -export get_extensions_v1beta1_a_p_i_resources -export list_extensions_v1beta1_daemon_set_for_all_namespaces -export list_extensions_v1beta1_deployment_for_all_namespaces -export list_extensions_v1beta1_ingress_for_all_namespaces -export list_extensions_v1beta1_namespaced_daemon_set -export list_extensions_v1beta1_namespaced_deployment -export list_extensions_v1beta1_namespaced_ingress -export list_extensions_v1beta1_namespaced_network_policy -export list_extensions_v1beta1_namespaced_replica_set -export list_extensions_v1beta1_network_policy_for_all_namespaces -export list_extensions_v1beta1_pod_security_policy -export list_extensions_v1beta1_replica_set_for_all_namespaces -export patch_extensions_v1beta1_namespaced_daemon_set -export patch_extensions_v1beta1_namespaced_daemon_set_status -export patch_extensions_v1beta1_namespaced_deployment -export patch_extensions_v1beta1_namespaced_deployment_scale -export patch_extensions_v1beta1_namespaced_deployment_status -export patch_extensions_v1beta1_namespaced_ingress -export patch_extensions_v1beta1_namespaced_ingress_status -export patch_extensions_v1beta1_namespaced_network_policy -export patch_extensions_v1beta1_namespaced_replica_set -export patch_extensions_v1beta1_namespaced_replica_set_scale -export patch_extensions_v1beta1_namespaced_replica_set_status -export patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale -export patch_extensions_v1beta1_pod_security_policy -export read_extensions_v1beta1_namespaced_daemon_set -export read_extensions_v1beta1_namespaced_daemon_set_status -export read_extensions_v1beta1_namespaced_deployment -export read_extensions_v1beta1_namespaced_deployment_scale -export read_extensions_v1beta1_namespaced_deployment_status -export read_extensions_v1beta1_namespaced_ingress -export read_extensions_v1beta1_namespaced_ingress_status -export read_extensions_v1beta1_namespaced_network_policy -export read_extensions_v1beta1_namespaced_replica_set -export read_extensions_v1beta1_namespaced_replica_set_scale -export read_extensions_v1beta1_namespaced_replica_set_status -export read_extensions_v1beta1_namespaced_replication_controller_dummy_scale -export read_extensions_v1beta1_pod_security_policy -export replace_extensions_v1beta1_namespaced_daemon_set -export replace_extensions_v1beta1_namespaced_daemon_set_status -export replace_extensions_v1beta1_namespaced_deployment -export replace_extensions_v1beta1_namespaced_deployment_scale -export replace_extensions_v1beta1_namespaced_deployment_status -export replace_extensions_v1beta1_namespaced_ingress -export replace_extensions_v1beta1_namespaced_ingress_status -export replace_extensions_v1beta1_namespaced_network_policy -export replace_extensions_v1beta1_namespaced_replica_set -export replace_extensions_v1beta1_namespaced_replica_set_scale -export replace_extensions_v1beta1_namespaced_replica_set_status -export replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale -export replace_extensions_v1beta1_pod_security_policy -export watch_extensions_v1beta1_daemon_set_list_for_all_namespaces -export watch_extensions_v1beta1_deployment_list_for_all_namespaces -export watch_extensions_v1beta1_ingress_list_for_all_namespaces -export watch_extensions_v1beta1_namespaced_daemon_set -export watch_extensions_v1beta1_namespaced_daemon_set_list -export watch_extensions_v1beta1_namespaced_deployment -export watch_extensions_v1beta1_namespaced_deployment_list -export watch_extensions_v1beta1_namespaced_ingress -export watch_extensions_v1beta1_namespaced_ingress_list -export watch_extensions_v1beta1_namespaced_network_policy -export watch_extensions_v1beta1_namespaced_network_policy_list -export watch_extensions_v1beta1_namespaced_replica_set -export watch_extensions_v1beta1_namespaced_replica_set_list -export watch_extensions_v1beta1_network_policy_list_for_all_namespaces -export watch_extensions_v1beta1_pod_security_policy -export watch_extensions_v1beta1_pod_security_policy_list -export watch_extensions_v1beta1_replica_set_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_FlowcontrolApiserverApi.jl b/src/ApiImpl/api/apis/api_FlowcontrolApiserverApi.jl deleted file mode 100644 index a8332548..00000000 --- a/src/ApiImpl/api/apis/api_FlowcontrolApiserverApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct FlowcontrolApiserverApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `FlowcontrolApiserverApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ FlowcontrolApiserverApi }) = "http://localhost" - -const _returntypes_get_flowcontrol_apiserver_a_p_i_group_FlowcontrolApiserverApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_flowcontrol_apiserver_a_p_i_group(_api::FlowcontrolApiserverApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_flowcontrol_apiserver_a_p_i_group_FlowcontrolApiserverApi, "/apis/flowcontrol.apiserver.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_flowcontrol_apiserver_a_p_i_group(_api::FlowcontrolApiserverApi; _mediaType=nothing) - _ctx = _oacinternal_get_flowcontrol_apiserver_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_flowcontrol_apiserver_a_p_i_group(_api::FlowcontrolApiserverApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_flowcontrol_apiserver_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_flowcontrol_apiserver_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_FlowcontrolApiserverV1alpha1Api.jl b/src/ApiImpl/api/apis/api_FlowcontrolApiserverV1alpha1Api.jl deleted file mode 100644 index fe75d48c..00000000 --- a/src/ApiImpl/api/apis/api_FlowcontrolApiserverV1alpha1Api.jl +++ /dev/null @@ -1,1058 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct FlowcontrolApiserverV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `FlowcontrolApiserverV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ FlowcontrolApiserverV1alpha1Api }) = "http://localhost" - -const _returntypes_create_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a FlowSchema - -Params: -- body::IoK8sApiFlowcontrolV1alpha1FlowSchema (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function create_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_flowcontrol_apiserver_v1alpha1_flow_schema(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_flowcontrol_apiserver_v1alpha1_flow_schema(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PriorityLevelConfiguration - -Params: -- body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of FlowSchema - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PriorityLevelConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a FlowSchema - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PriorityLevelConfiguration - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_flowcontrol_apiserver_v1alpha1_a_p_i_resources_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api::FlowcontrolApiserverV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_flowcontrol_apiserver_v1alpha1_a_p_i_resources_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api::FlowcontrolApiserverV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchemaList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind FlowSchema - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchemaList, OpenAPI.Clients.ApiResponse -""" -function list_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_flowcontrol_apiserver_v1alpha1_flow_schema(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_flowcontrol_apiserver_v1alpha1_flow_schema(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PriorityLevelConfiguration - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, OpenAPI.Clients.ApiResponse -""" -function list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified FlowSchema - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified FlowSchema - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified FlowSchema - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function read_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified FlowSchema - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified FlowSchema - -Params: -- name::String (required) -- body::IoK8sApiFlowcontrolV1alpha1FlowSchema (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1FlowSchema, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_flowcontrol_apiserver_v1alpha1_flow_schema_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified FlowSchema - -Params: -- name::String (required) -- body::IoK8sApiFlowcontrolV1alpha1FlowSchema (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1FlowSchema, OpenAPI.Clients.ApiResponse -""" -function replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiFlowcontrolV1alpha1FlowSchema; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified PriorityLevelConfiguration - -Params: -- name::String (required) -- body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, OpenAPI.Clients.ApiResponse -""" -function replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_flowcontrol_apiserver_v1alpha1_flow_schema_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind FlowSchema. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_flowcontrol_apiserver_v1alpha1_flow_schema_list_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api::FlowcontrolApiserverV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_flowcontrol_apiserver_v1alpha1_flow_schema_list_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of FlowSchema. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api::FlowcontrolApiserverV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list_FlowcontrolApiserverV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api::FlowcontrolApiserverV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list_FlowcontrolApiserverV1alpha1Api, "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api::FlowcontrolApiserverV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api::FlowcontrolApiserverV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_flowcontrol_apiserver_v1alpha1_flow_schema -export create_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema -export delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration -export delete_flowcontrol_apiserver_v1alpha1_flow_schema -export delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export get_flowcontrol_apiserver_v1alpha1_a_p_i_resources -export list_flowcontrol_apiserver_v1alpha1_flow_schema -export list_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export patch_flowcontrol_apiserver_v1alpha1_flow_schema -export patch_flowcontrol_apiserver_v1alpha1_flow_schema_status -export patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status -export read_flowcontrol_apiserver_v1alpha1_flow_schema -export read_flowcontrol_apiserver_v1alpha1_flow_schema_status -export read_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status -export replace_flowcontrol_apiserver_v1alpha1_flow_schema -export replace_flowcontrol_apiserver_v1alpha1_flow_schema_status -export replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status -export watch_flowcontrol_apiserver_v1alpha1_flow_schema -export watch_flowcontrol_apiserver_v1alpha1_flow_schema_list -export watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration -export watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list diff --git a/src/ApiImpl/api/apis/api_KarpenterShV1alpha5Api.jl b/src/ApiImpl/api/apis/api_KarpenterShV1alpha5Api.jl deleted file mode 100644 index f59356fd..00000000 --- a/src/ApiImpl/api/apis/api_KarpenterShV1alpha5Api.jl +++ /dev/null @@ -1,416 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct KarpenterShV1alpha5Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `KarpenterShV1alpha5Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ KarpenterShV1alpha5Api }) = "http://localhost" - -const _returntypes_create_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("201", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("202", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json", "application/yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Provisioner - -Params: -- body::ShKarpenterV1alpha5Provisioner (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function create_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_karpenter_sh_v1alpha5_provisioner(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_karpenter_sh_v1alpha5_provisioner(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_karpenter_sh_v1alpha5_collection_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1StatusV2, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_karpenter_sh_v1alpha5_collection_provisioner(_api::KarpenterShV1alpha5Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_karpenter_sh_v1alpha5_collection_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Provisioner - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1StatusV2, OpenAPI.Clients.ApiResponse -""" -function delete_karpenter_sh_v1alpha5_collection_provisioner(_api::KarpenterShV1alpha5Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_karpenter_sh_v1alpha5_collection_provisioner(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_karpenter_sh_v1alpha5_collection_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_karpenter_sh_v1alpha5_collection_provisioner(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1StatusV2, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1StatusV2, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json", "application/yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Provisioner - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 - -Return: IoK8sApimachineryPkgApisMetaV1StatusV2, OpenAPI.Clients.ApiResponse -""" -function delete_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_karpenter_sh_v1alpha5_provisioner(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_karpenter_sh_v1alpha5_provisioner(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5ProvisionerList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersionMatch", resource_version_match) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list objects of kind Provisioner - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- resource_version_match::String -- timeout_seconds::Int64 -- watch::Bool - -Return: ShKarpenterV1alpha5ProvisionerList, OpenAPI.Clients.ApiResponse -""" -function list_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_karpenter_sh_v1alpha5_provisioner(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, resource_version_match=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_karpenter_sh_v1alpha5_provisioner(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, resource_version_match=resource_version_match, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Provisioner - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function patch_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_karpenter_sh_v1alpha5_provisioner(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_karpenter_sh_v1alpha5_provisioner(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Provisioner - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function patch_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_karpenter_sh_v1alpha5_provisioner_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_karpenter_sh_v1alpha5_provisioner_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Provisioner - -Params: -- name::String (required) -- pretty::String -- resource_version::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function read_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_karpenter_sh_v1alpha5_provisioner(_api, name; pretty=pretty, resource_version=resource_version, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_karpenter_sh_v1alpha5_provisioner(_api, name; pretty=pretty, resource_version=resource_version, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Provisioner - -Params: -- name::String (required) -- pretty::String -- resource_version::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function read_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_karpenter_sh_v1alpha5_provisioner_status(_api, name; pretty=pretty, resource_version=resource_version, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String; pretty=nothing, resource_version=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_karpenter_sh_v1alpha5_provisioner_status(_api, name; pretty=pretty, resource_version=resource_version, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("201", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_karpenter_sh_v1alpha5_provisioner_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json", "application/yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Provisioner - -Params: -- name::String (required) -- body::ShKarpenterV1alpha5Provisioner (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function replace_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_karpenter_sh_v1alpha5_provisioner(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_karpenter_sh_v1alpha5_provisioner(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_karpenter_sh_v1alpha5_provisioner(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("201", "x"=>".") * "\$") => ShKarpenterV1alpha5Provisioner, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_karpenter_sh_v1alpha5_provisioner_status_KarpenterShV1alpha5Api, "/apis/karpenter.sh/v1alpha5/provisioners/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json", "application/yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Provisioner - -Params: -- name::String (required) -- body::ShKarpenterV1alpha5Provisioner (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: ShKarpenterV1alpha5Provisioner, OpenAPI.Clients.ApiResponse -""" -function replace_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_karpenter_sh_v1alpha5_provisioner_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_karpenter_sh_v1alpha5_provisioner_status(_api::KarpenterShV1alpha5Api, response_stream::Channel, name::String, body::ShKarpenterV1alpha5Provisioner; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_karpenter_sh_v1alpha5_provisioner_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_karpenter_sh_v1alpha5_provisioner -export delete_karpenter_sh_v1alpha5_collection_provisioner -export delete_karpenter_sh_v1alpha5_provisioner -export list_karpenter_sh_v1alpha5_provisioner -export patch_karpenter_sh_v1alpha5_provisioner -export patch_karpenter_sh_v1alpha5_provisioner_status -export read_karpenter_sh_v1alpha5_provisioner -export read_karpenter_sh_v1alpha5_provisioner_status -export replace_karpenter_sh_v1alpha5_provisioner -export replace_karpenter_sh_v1alpha5_provisioner_status diff --git a/src/ApiImpl/api/apis/api_LogsApi.jl b/src/ApiImpl/api/apis/api_LogsApi.jl deleted file mode 100644 index cd5f13a0..00000000 --- a/src/ApiImpl/api/apis/api_LogsApi.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct LogsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `LogsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ LogsApi }) = "http://localhost" - -const _returntypes_log_file_handler_LogsApi = Dict{Regex,Type}( - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_log_file_handler(_api::LogsApi, logpath::String; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_log_file_handler_LogsApi, "/logs/{logpath}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "logpath", logpath) # type String - OpenAPI.Clients.set_header_accept(_ctx, []) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""Params: -- logpath::String (required) - -Return: Nothing, OpenAPI.Clients.ApiResponse -""" -function log_file_handler(_api::LogsApi, logpath::String; _mediaType=nothing) - _ctx = _oacinternal_log_file_handler(_api, logpath; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function log_file_handler(_api::LogsApi, response_stream::Channel, logpath::String; _mediaType=nothing) - _ctx = _oacinternal_log_file_handler(_api, logpath; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_log_file_list_handler_LogsApi = Dict{Regex,Type}( - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_log_file_list_handler(_api::LogsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_log_file_list_handler_LogsApi, "/logs/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, []) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""Params: - -Return: Nothing, OpenAPI.Clients.ApiResponse -""" -function log_file_list_handler(_api::LogsApi; _mediaType=nothing) - _ctx = _oacinternal_log_file_list_handler(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function log_file_list_handler(_api::LogsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_log_file_list_handler(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export log_file_handler -export log_file_list_handler diff --git a/src/ApiImpl/api/apis/api_MetricsV1beta1Api.jl b/src/ApiImpl/api/apis/api_MetricsV1beta1Api.jl deleted file mode 100644 index a8eb2573..00000000 --- a/src/ApiImpl/api/apis/api_MetricsV1beta1Api.jl +++ /dev/null @@ -1,179 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct MetricsV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `MetricsV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ MetricsV1beta1Api }) = "http://localhost" - -const _returntypes_list_metrics_v1beta1_node_metrics_MetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiMetricsV1beta1NodeMetricsList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_metrics_v1beta1_node_metrics_MetricsV1beta1Api, "/apis/metrics.k8s.io/v1beta1/nodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind NodeMetrics - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiMetricsV1beta1NodeMetricsList, OpenAPI.Clients.ApiResponse -""" -function list_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_metrics_v1beta1_node_metrics(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_metrics_v1beta1_node_metrics(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_metrics_v1beta1_pod_metrics_MetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiMetricsV1beta1PodMetricsList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_metrics_v1beta1_pod_metrics(_api::MetricsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_metrics_v1beta1_pod_metrics_MetricsV1beta1Api, "/apis/metrics.k8s.io/v1beta1/pods", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodMetrics - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiMetricsV1beta1PodMetricsList, OpenAPI.Clients.ApiResponse -""" -function list_metrics_v1beta1_pod_metrics(_api::MetricsV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_metrics_v1beta1_pod_metrics(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_metrics_v1beta1_pod_metrics(_api::MetricsV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_metrics_v1beta1_pod_metrics(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_metrics_v1beta1_namespaced_pod_metrics_MetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiMetricsV1beta1PodMetrics, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_metrics_v1beta1_namespaced_pod_metrics(_api::MetricsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_metrics_v1beta1_namespaced_pod_metrics_MetricsV1beta1Api, "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodMetrics - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiMetricsV1beta1PodMetrics, OpenAPI.Clients.ApiResponse -""" -function read_metrics_v1beta1_namespaced_pod_metrics(_api::MetricsV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_metrics_v1beta1_namespaced_pod_metrics(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_metrics_v1beta1_namespaced_pod_metrics(_api::MetricsV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_metrics_v1beta1_namespaced_pod_metrics(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_metrics_v1beta1_node_metrics_MetricsV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiMetricsV1beta1NodeMetrics, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_metrics_v1beta1_node_metrics_MetricsV1beta1Api, "/apis/metrics.k8s.io/v1beta1/nodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified NodeMetrics - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiMetricsV1beta1NodeMetrics, OpenAPI.Clients.ApiResponse -""" -function read_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_metrics_v1beta1_node_metrics(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_metrics_v1beta1_node_metrics(_api::MetricsV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_metrics_v1beta1_node_metrics(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export list_metrics_v1beta1_node_metrics -export list_metrics_v1beta1_pod_metrics -export read_metrics_v1beta1_namespaced_pod_metrics -export read_metrics_v1beta1_node_metrics diff --git a/src/ApiImpl/api/apis/api_NetworkingApi.jl b/src/ApiImpl/api/apis/api_NetworkingApi.jl deleted file mode 100644 index a2fc96cc..00000000 --- a/src/ApiImpl/api/apis/api_NetworkingApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NetworkingApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NetworkingApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NetworkingApi }) = "http://localhost" - -const _returntypes_get_networking_a_p_i_group_NetworkingApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_networking_a_p_i_group(_api::NetworkingApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_networking_a_p_i_group_NetworkingApi, "/apis/networking.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_networking_a_p_i_group(_api::NetworkingApi; _mediaType=nothing) - _ctx = _oacinternal_get_networking_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_networking_a_p_i_group(_api::NetworkingApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_networking_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_networking_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_NetworkingV1Api.jl b/src/ApiImpl/api/apis/api_NetworkingV1Api.jl deleted file mode 100644 index eb8c4445..00000000 --- a/src/ApiImpl/api/apis/api_NetworkingV1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NetworkingV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NetworkingV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NetworkingV1Api }) = "http://localhost" - -const _returntypes_create_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a NetworkPolicy - -Params: -- namespace::String (required) -- body::IoK8sApiNetworkingV1NetworkPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNetworkingV1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function create_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_networking_v1_namespaced_network_policy(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_networking_v1_namespaced_network_policy(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_networking_v1_collection_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_networking_v1_collection_namespaced_network_policy(_api::NetworkingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_networking_v1_collection_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of NetworkPolicy - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_networking_v1_collection_namespaced_network_policy(_api::NetworkingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1_collection_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_networking_v1_collection_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1_collection_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1_namespaced_network_policy(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1_namespaced_network_policy(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_networking_v1_a_p_i_resources_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_networking_v1_a_p_i_resources(_api::NetworkingV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_networking_v1_a_p_i_resources_NetworkingV1Api, "/apis/networking.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_networking_v1_a_p_i_resources(_api::NetworkingV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_networking_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_networking_v1_a_p_i_resources(_api::NetworkingV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_networking_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind NetworkPolicy - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNetworkingV1NetworkPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1_namespaced_network_policy(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_networking_v1_network_policy_for_all_namespaces_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_networking_v1_network_policy_for_all_namespaces(_api::NetworkingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_networking_v1_network_policy_for_all_namespaces_NetworkingV1Api, "/apis/networking.k8s.io/v1/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind NetworkPolicy - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNetworkingV1NetworkPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_networking_v1_network_policy_for_all_namespaces(_api::NetworkingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1_network_policy_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_networking_v1_network_policy_for_all_namespaces(_api::NetworkingV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1_network_policy_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiNetworkingV1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function patch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiNetworkingV1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function read_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1_namespaced_network_policy(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1_namespaced_network_policy(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNetworkingV1NetworkPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified NetworkPolicy - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiNetworkingV1NetworkPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNetworkingV1NetworkPolicy, OpenAPI.Clients.ApiResponse -""" -function replace_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1_namespaced_network_policy(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1_namespaced_network_policy_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1_namespaced_network_policy_NetworkingV1Api, "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_namespaced_network_policy(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1_namespaced_network_policy(_api::NetworkingV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_namespaced_network_policy(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1_namespaced_network_policy_list_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1_namespaced_network_policy_list(_api::NetworkingV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1_namespaced_network_policy_list_NetworkingV1Api, "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1_namespaced_network_policy_list(_api::NetworkingV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_namespaced_network_policy_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1_namespaced_network_policy_list(_api::NetworkingV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_namespaced_network_policy_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1_network_policy_list_for_all_namespaces_NetworkingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1_network_policy_list_for_all_namespaces(_api::NetworkingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1_network_policy_list_for_all_namespaces_NetworkingV1Api, "/apis/networking.k8s.io/v1/watch/networkpolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1_network_policy_list_for_all_namespaces(_api::NetworkingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_network_policy_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1_network_policy_list_for_all_namespaces(_api::NetworkingV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1_network_policy_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_networking_v1_namespaced_network_policy -export delete_networking_v1_collection_namespaced_network_policy -export delete_networking_v1_namespaced_network_policy -export get_networking_v1_a_p_i_resources -export list_networking_v1_namespaced_network_policy -export list_networking_v1_network_policy_for_all_namespaces -export patch_networking_v1_namespaced_network_policy -export read_networking_v1_namespaced_network_policy -export replace_networking_v1_namespaced_network_policy -export watch_networking_v1_namespaced_network_policy -export watch_networking_v1_namespaced_network_policy_list -export watch_networking_v1_network_policy_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_NetworkingV1beta1Api.jl b/src/ApiImpl/api/apis/api_NetworkingV1beta1Api.jl deleted file mode 100644 index 53367662..00000000 --- a/src/ApiImpl/api/apis/api_NetworkingV1beta1Api.jl +++ /dev/null @@ -1,668 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NetworkingV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NetworkingV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NetworkingV1beta1Api }) = "http://localhost" - -const _returntypes_create_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create an Ingress - -Params: -- namespace::String (required) -- body::IoK8sApiNetworkingV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function create_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_networking_v1beta1_namespaced_ingress(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_networking_v1beta1_namespaced_ingress(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_networking_v1beta1_collection_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_networking_v1beta1_collection_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_networking_v1beta1_collection_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Ingress - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_networking_v1beta1_collection_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1beta1_collection_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_networking_v1beta1_collection_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1beta1_collection_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete an Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_networking_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_networking_v1beta1_a_p_i_resources_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_networking_v1beta1_a_p_i_resources(_api::NetworkingV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_networking_v1beta1_a_p_i_resources_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_networking_v1beta1_a_p_i_resources(_api::NetworkingV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_networking_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_networking_v1beta1_a_p_i_resources(_api::NetworkingV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_networking_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_networking_v1beta1_ingress_for_all_namespaces_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1IngressList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_networking_v1beta1_ingress_for_all_namespaces(_api::NetworkingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_networking_v1beta1_ingress_for_all_namespaces_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Ingress - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNetworkingV1beta1IngressList, OpenAPI.Clients.ApiResponse -""" -function list_networking_v1beta1_ingress_for_all_namespaces(_api::NetworkingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1beta1_ingress_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_networking_v1beta1_ingress_for_all_namespaces(_api::NetworkingV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1beta1_ingress_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1IngressList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Ingress - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNetworkingV1beta1IngressList, OpenAPI.Clients.ApiResponse -""" -function list_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1beta1_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_networking_v1beta1_namespaced_ingress(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function patch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function patch_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_networking_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function read_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1beta1_namespaced_ingress(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function read_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1beta1_namespaced_ingress_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_networking_v1beta1_namespaced_ingress_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiNetworkingV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function replace_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1beta1_namespaced_ingress(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNetworkingV1beta1Ingress, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_networking_v1beta1_namespaced_ingress_status_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified Ingress - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiNetworkingV1beta1Ingress (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNetworkingV1beta1Ingress, OpenAPI.Clients.ApiResponse -""" -function replace_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_networking_v1beta1_namespaced_ingress_status(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiNetworkingV1beta1Ingress; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_networking_v1beta1_namespaced_ingress_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1beta1_ingress_list_for_all_namespaces_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1beta1_ingress_list_for_all_namespaces(_api::NetworkingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1beta1_ingress_list_for_all_namespaces_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/watch/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1beta1_ingress_list_for_all_namespaces(_api::NetworkingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_ingress_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1beta1_ingress_list_for_all_namespaces(_api::NetworkingV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_ingress_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1beta1_namespaced_ingress_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/watch/namespaces/{namespace}/ingresses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_namespaced_ingress(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1beta1_namespaced_ingress(_api::NetworkingV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_namespaced_ingress(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_networking_v1beta1_namespaced_ingress_list_NetworkingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_networking_v1beta1_namespaced_ingress_list(_api::NetworkingV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_networking_v1beta1_namespaced_ingress_list_NetworkingV1beta1Api, "/apis/networking.k8s.io/v1beta1/watch/namespaces/{namespace}/ingresses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_networking_v1beta1_namespaced_ingress_list(_api::NetworkingV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_namespaced_ingress_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_networking_v1beta1_namespaced_ingress_list(_api::NetworkingV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_networking_v1beta1_namespaced_ingress_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_networking_v1beta1_namespaced_ingress -export delete_networking_v1beta1_collection_namespaced_ingress -export delete_networking_v1beta1_namespaced_ingress -export get_networking_v1beta1_a_p_i_resources -export list_networking_v1beta1_ingress_for_all_namespaces -export list_networking_v1beta1_namespaced_ingress -export patch_networking_v1beta1_namespaced_ingress -export patch_networking_v1beta1_namespaced_ingress_status -export read_networking_v1beta1_namespaced_ingress -export read_networking_v1beta1_namespaced_ingress_status -export replace_networking_v1beta1_namespaced_ingress -export replace_networking_v1beta1_namespaced_ingress_status -export watch_networking_v1beta1_ingress_list_for_all_namespaces -export watch_networking_v1beta1_namespaced_ingress -export watch_networking_v1beta1_namespaced_ingress_list diff --git a/src/ApiImpl/api/apis/api_NodeApi.jl b/src/ApiImpl/api/apis/api_NodeApi.jl deleted file mode 100644 index 478aa493..00000000 --- a/src/ApiImpl/api/apis/api_NodeApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NodeApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NodeApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NodeApi }) = "http://localhost" - -const _returntypes_get_node_a_p_i_group_NodeApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_node_a_p_i_group(_api::NodeApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_node_a_p_i_group_NodeApi, "/apis/node.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_node_a_p_i_group(_api::NodeApi; _mediaType=nothing) - _ctx = _oacinternal_get_node_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_node_a_p_i_group(_api::NodeApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_node_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_node_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_NodeV1alpha1Api.jl b/src/ApiImpl/api/apis/api_NodeV1alpha1Api.jl deleted file mode 100644 index 66798999..00000000 --- a/src/ApiImpl/api/apis/api_NodeV1alpha1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NodeV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NodeV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NodeV1alpha1Api }) = "http://localhost" - -const _returntypes_create_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a RuntimeClass - -Params: -- body::IoK8sApiNodeV1alpha1RuntimeClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNodeV1alpha1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function create_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_node_v1alpha1_runtime_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_node_v1alpha1_runtime_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_node_v1alpha1_collection_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_node_v1alpha1_collection_runtime_class(_api::NodeV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_node_v1alpha1_collection_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of RuntimeClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_node_v1alpha1_collection_runtime_class(_api::NodeV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1alpha1_collection_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_node_v1alpha1_collection_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1alpha1_collection_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a RuntimeClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1alpha1_runtime_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1alpha1_runtime_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_node_v1alpha1_a_p_i_resources_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_node_v1alpha1_a_p_i_resources(_api::NodeV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_node_v1alpha1_a_p_i_resources_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_node_v1alpha1_a_p_i_resources(_api::NodeV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_node_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_node_v1alpha1_a_p_i_resources(_api::NodeV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_node_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RuntimeClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNodeV1alpha1RuntimeClassList, OpenAPI.Clients.ApiResponse -""" -function list_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_node_v1alpha1_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_node_v1alpha1_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified RuntimeClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiNodeV1alpha1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function patch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_node_v1alpha1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_node_v1alpha1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified RuntimeClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiNodeV1alpha1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function read_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_node_v1alpha1_runtime_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_node_v1alpha1_runtime_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNodeV1alpha1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified RuntimeClass - -Params: -- name::String (required) -- body::IoK8sApiNodeV1alpha1RuntimeClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNodeV1alpha1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function replace_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_node_v1alpha1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiNodeV1alpha1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_node_v1alpha1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_node_v1alpha1_runtime_class_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_node_v1alpha1_runtime_class_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/watch/runtimeclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1alpha1_runtime_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_node_v1alpha1_runtime_class(_api::NodeV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1alpha1_runtime_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_node_v1alpha1_runtime_class_list_NodeV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_node_v1alpha1_runtime_class_list(_api::NodeV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_node_v1alpha1_runtime_class_list_NodeV1alpha1Api, "/apis/node.k8s.io/v1alpha1/watch/runtimeclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_node_v1alpha1_runtime_class_list(_api::NodeV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1alpha1_runtime_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_node_v1alpha1_runtime_class_list(_api::NodeV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1alpha1_runtime_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_node_v1alpha1_runtime_class -export delete_node_v1alpha1_collection_runtime_class -export delete_node_v1alpha1_runtime_class -export get_node_v1alpha1_a_p_i_resources -export list_node_v1alpha1_runtime_class -export patch_node_v1alpha1_runtime_class -export read_node_v1alpha1_runtime_class -export replace_node_v1alpha1_runtime_class -export watch_node_v1alpha1_runtime_class -export watch_node_v1alpha1_runtime_class_list diff --git a/src/ApiImpl/api/apis/api_NodeV1beta1Api.jl b/src/ApiImpl/api/apis/api_NodeV1beta1Api.jl deleted file mode 100644 index 445272bb..00000000 --- a/src/ApiImpl/api/apis/api_NodeV1beta1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct NodeV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `NodeV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ NodeV1beta1Api }) = "http://localhost" - -const _returntypes_create_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_node_v1beta1_runtime_class(_api::NodeV1beta1Api, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a RuntimeClass - -Params: -- body::IoK8sApiNodeV1beta1RuntimeClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNodeV1beta1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function create_node_v1beta1_runtime_class(_api::NodeV1beta1Api, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_node_v1beta1_runtime_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_node_v1beta1_runtime_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_node_v1beta1_collection_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_node_v1beta1_collection_runtime_class(_api::NodeV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_node_v1beta1_collection_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of RuntimeClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_node_v1beta1_collection_runtime_class(_api::NodeV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1beta1_collection_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_node_v1beta1_collection_runtime_class(_api::NodeV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1beta1_collection_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a RuntimeClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1beta1_runtime_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_node_v1beta1_runtime_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_node_v1beta1_a_p_i_resources_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_node_v1beta1_a_p_i_resources(_api::NodeV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_node_v1beta1_a_p_i_resources_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_node_v1beta1_a_p_i_resources(_api::NodeV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_node_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_node_v1beta1_a_p_i_resources(_api::NodeV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_node_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_node_v1beta1_runtime_class(_api::NodeV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RuntimeClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiNodeV1beta1RuntimeClassList, OpenAPI.Clients.ApiResponse -""" -function list_node_v1beta1_runtime_class(_api::NodeV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_node_v1beta1_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_node_v1beta1_runtime_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified RuntimeClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiNodeV1beta1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function patch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_node_v1beta1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_node_v1beta1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified RuntimeClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiNodeV1beta1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function read_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_node_v1beta1_runtime_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_node_v1beta1_runtime_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiNodeV1beta1RuntimeClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/runtimeclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified RuntimeClass - -Params: -- name::String (required) -- body::IoK8sApiNodeV1beta1RuntimeClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiNodeV1beta1RuntimeClass, OpenAPI.Clients.ApiResponse -""" -function replace_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_node_v1beta1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiNodeV1beta1RuntimeClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_node_v1beta1_runtime_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_node_v1beta1_runtime_class_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_node_v1beta1_runtime_class_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/watch/runtimeclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1beta1_runtime_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_node_v1beta1_runtime_class(_api::NodeV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1beta1_runtime_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_node_v1beta1_runtime_class_list_NodeV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_node_v1beta1_runtime_class_list(_api::NodeV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_node_v1beta1_runtime_class_list_NodeV1beta1Api, "/apis/node.k8s.io/v1beta1/watch/runtimeclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_node_v1beta1_runtime_class_list(_api::NodeV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1beta1_runtime_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_node_v1beta1_runtime_class_list(_api::NodeV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_node_v1beta1_runtime_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_node_v1beta1_runtime_class -export delete_node_v1beta1_collection_runtime_class -export delete_node_v1beta1_runtime_class -export get_node_v1beta1_a_p_i_resources -export list_node_v1beta1_runtime_class -export patch_node_v1beta1_runtime_class -export read_node_v1beta1_runtime_class -export replace_node_v1beta1_runtime_class -export watch_node_v1beta1_runtime_class -export watch_node_v1beta1_runtime_class_list diff --git a/src/ApiImpl/api/apis/api_PolicyApi.jl b/src/ApiImpl/api/apis/api_PolicyApi.jl deleted file mode 100644 index 4007f09d..00000000 --- a/src/ApiImpl/api/apis/api_PolicyApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct PolicyApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `PolicyApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ PolicyApi }) = "http://localhost" - -const _returntypes_get_policy_a_p_i_group_PolicyApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_policy_a_p_i_group(_api::PolicyApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_policy_a_p_i_group_PolicyApi, "/apis/policy/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_policy_a_p_i_group(_api::PolicyApi; _mediaType=nothing) - _ctx = _oacinternal_get_policy_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_policy_a_p_i_group(_api::PolicyApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_policy_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_policy_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_PolicyV1beta1Api.jl b/src/ApiImpl/api/apis/api_PolicyV1beta1Api.jl deleted file mode 100644 index 51a36ef0..00000000 --- a/src/ApiImpl/api/apis/api_PolicyV1beta1Api.jl +++ /dev/null @@ -1,1064 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct PolicyV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `PolicyV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ PolicyV1beta1Api }) = "http://localhost" - -const _returntypes_create_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PodDisruptionBudget - -Params: -- namespace::String (required) -- body::IoK8sApiPolicyV1beta1PodDisruptionBudget (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function create_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_policy_v1beta1_namespaced_pod_disruption_budget(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_policy_v1beta1_namespaced_pod_disruption_budget(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PodSecurityPolicy - -Params: -- body::IoK8sApiPolicyV1beta1PodSecurityPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiPolicyV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function create_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_policy_v1beta1_pod_security_policy(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_policy_v1beta1_pod_security_policy(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_policy_v1beta1_collection_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_policy_v1beta1_collection_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PodDisruptionBudget - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_policy_v1beta1_collection_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_policy_v1beta1_collection_pod_security_policy(_api::PolicyV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_policy_v1beta1_collection_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PodSecurityPolicy - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_policy_v1beta1_collection_pod_security_policy(_api::PolicyV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_collection_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_policy_v1beta1_collection_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_collection_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PodSecurityPolicy - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_pod_security_policy(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_policy_v1beta1_pod_security_policy(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_policy_v1beta1_a_p_i_resources_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_policy_v1beta1_a_p_i_resources(_api::PolicyV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_policy_v1beta1_a_p_i_resources_PolicyV1beta1Api, "/apis/policy/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_policy_v1beta1_a_p_i_resources(_api::PolicyV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_policy_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_policy_v1beta1_a_p_i_resources(_api::PolicyV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_policy_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudgetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodDisruptionBudget - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudgetList, OpenAPI.Clients.ApiResponse -""" -function list_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_namespaced_pod_disruption_budget(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_namespaced_pod_disruption_budget(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_policy_v1beta1_pod_disruption_budget_for_all_namespaces_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudgetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_policy_v1beta1_pod_disruption_budget_for_all_namespaces_PolicyV1beta1Api, "/apis/policy/v1beta1/poddisruptionbudgets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodDisruptionBudget - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudgetList, OpenAPI.Clients.ApiResponse -""" -function list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api::PolicyV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicyList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodSecurityPolicy - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiPolicyV1beta1PodSecurityPolicyList, OpenAPI.Clients.ApiResponse -""" -function list_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_policy_v1beta1_pod_security_policy(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function patch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PodSecurityPolicy - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiPolicyV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function patch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_policy_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function read_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodSecurityPolicy - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiPolicyV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function read_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_pod_security_policy(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_policy_v1beta1_pod_security_policy(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiPolicyV1beta1PodDisruptionBudget (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function replace_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodDisruptionBudget, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_policy_v1beta1_namespaced_pod_disruption_budget_status_PolicyV1beta1Api, "/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified PodDisruptionBudget - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiPolicyV1beta1PodDisruptionBudget (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiPolicyV1beta1PodDisruptionBudget, OpenAPI.Clients.ApiResponse -""" -function replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiPolicyV1beta1PodDisruptionBudget; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiPolicyV1beta1PodSecurityPolicy, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/podsecuritypolicies/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PodSecurityPolicy - -Params: -- name::String (required) -- body::IoK8sApiPolicyV1beta1PodSecurityPolicy (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiPolicyV1beta1PodSecurityPolicy, OpenAPI.Clients.ApiResponse -""" -function replace_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiPolicyV1beta1PodSecurityPolicy; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_policy_v1beta1_pod_security_policy(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_policy_v1beta1_namespaced_pod_disruption_budget_PolicyV1beta1Api, "/apis/policy/v1beta1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_policy_v1beta1_namespaced_pod_disruption_budget(_api::PolicyV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_policy_v1beta1_namespaced_pod_disruption_budget_list_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api::PolicyV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_policy_v1beta1_namespaced_pod_disruption_budget_list_PolicyV1beta1Api, "/apis/policy/v1beta1/watch/namespaces/{namespace}/poddisruptionbudgets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api::PolicyV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api::PolicyV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces_PolicyV1beta1Api, "/apis/policy/v1beta1/watch/poddisruptionbudgets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api::PolicyV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_policy_v1beta1_pod_security_policy_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_policy_v1beta1_pod_security_policy_PolicyV1beta1Api, "/apis/policy/v1beta1/watch/podsecuritypolicies/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_security_policy(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_policy_v1beta1_pod_security_policy(_api::PolicyV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_security_policy(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_policy_v1beta1_pod_security_policy_list_PolicyV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_policy_v1beta1_pod_security_policy_list(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_policy_v1beta1_pod_security_policy_list_PolicyV1beta1Api, "/apis/policy/v1beta1/watch/podsecuritypolicies", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_policy_v1beta1_pod_security_policy_list(_api::PolicyV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_security_policy_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_policy_v1beta1_pod_security_policy_list(_api::PolicyV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_policy_v1beta1_pod_security_policy_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_policy_v1beta1_namespaced_pod_disruption_budget -export create_policy_v1beta1_pod_security_policy -export delete_policy_v1beta1_collection_namespaced_pod_disruption_budget -export delete_policy_v1beta1_collection_pod_security_policy -export delete_policy_v1beta1_namespaced_pod_disruption_budget -export delete_policy_v1beta1_pod_security_policy -export get_policy_v1beta1_a_p_i_resources -export list_policy_v1beta1_namespaced_pod_disruption_budget -export list_policy_v1beta1_pod_disruption_budget_for_all_namespaces -export list_policy_v1beta1_pod_security_policy -export patch_policy_v1beta1_namespaced_pod_disruption_budget -export patch_policy_v1beta1_namespaced_pod_disruption_budget_status -export patch_policy_v1beta1_pod_security_policy -export read_policy_v1beta1_namespaced_pod_disruption_budget -export read_policy_v1beta1_namespaced_pod_disruption_budget_status -export read_policy_v1beta1_pod_security_policy -export replace_policy_v1beta1_namespaced_pod_disruption_budget -export replace_policy_v1beta1_namespaced_pod_disruption_budget_status -export replace_policy_v1beta1_pod_security_policy -export watch_policy_v1beta1_namespaced_pod_disruption_budget -export watch_policy_v1beta1_namespaced_pod_disruption_budget_list -export watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces -export watch_policy_v1beta1_pod_security_policy -export watch_policy_v1beta1_pod_security_policy_list diff --git a/src/ApiImpl/api/apis/api_RbacAuthorizationApi.jl b/src/ApiImpl/api/apis/api_RbacAuthorizationApi.jl deleted file mode 100644 index 20610212..00000000 --- a/src/ApiImpl/api/apis/api_RbacAuthorizationApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct RbacAuthorizationApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `RbacAuthorizationApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ RbacAuthorizationApi }) = "http://localhost" - -const _returntypes_get_rbac_authorization_a_p_i_group_RbacAuthorizationApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_rbac_authorization_a_p_i_group(_api::RbacAuthorizationApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_rbac_authorization_a_p_i_group_RbacAuthorizationApi, "/apis/rbac.authorization.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_rbac_authorization_a_p_i_group(_api::RbacAuthorizationApi; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_rbac_authorization_a_p_i_group(_api::RbacAuthorizationApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_rbac_authorization_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_RbacAuthorizationV1Api.jl b/src/ApiImpl/api/apis/api_RbacAuthorizationV1Api.jl deleted file mode 100644 index 0669e75a..00000000 --- a/src/ApiImpl/api/apis/api_RbacAuthorizationV1Api.jl +++ /dev/null @@ -1,1834 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct RbacAuthorizationV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `RbacAuthorizationV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ RbacAuthorizationV1Api }) = "http://localhost" - -const _returntypes_create_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRole - -Params: -- body::IoK8sApiRbacV1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRoleBinding - -Params: -- body::IoK8sApiRbacV1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Role - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1Role, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a RoleBinding - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRole - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_collection_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_collection_cluster_role(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_collection_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_collection_cluster_role(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_collection_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_collection_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_collection_cluster_role_binding(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_collection_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_collection_cluster_role_binding(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_collection_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_collection_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_collection_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_collection_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_collection_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_collection_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_collection_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_collection_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_collection_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_rbac_authorization_v1_a_p_i_resources_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_rbac_authorization_v1_a_p_i_resources(_api::RbacAuthorizationV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_rbac_authorization_v1_a_p_i_resources_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_rbac_authorization_v1_a_p_i_resources(_api::RbacAuthorizationV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_rbac_authorization_v1_a_p_i_resources(_api::RbacAuthorizationV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1ClusterRoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1ClusterRoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_role_binding_for_all_namespaces_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_role_binding_for_all_namespaces_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1_role_for_all_namespaces_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1_role_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1_role_for_all_namespaces_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1_role_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1_role_for_all_namespaces(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRole - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1Role, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRole - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1Role, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRole - -Params: -- name::String (required) -- body::IoK8sApiRbacV1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::IoK8sApiRbacV1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1Role, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_cluster_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_cluster_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_cluster_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_cluster_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_cluster_role_binding_list_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_cluster_role_binding_list(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_cluster_role_binding_list_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_cluster_role_binding_list(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_cluster_role_binding_list(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_cluster_role_list_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_cluster_role_list(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_cluster_role_list_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_cluster_role_list(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_cluster_role_list(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_namespaced_role_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_namespaced_role(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_namespaced_role_binding_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_namespaced_role_binding(_api::RbacAuthorizationV1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_namespaced_role_binding_list_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding_list(_api::RbacAuthorizationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_namespaced_role_binding_list_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_namespaced_role_binding_list(_api::RbacAuthorizationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_namespaced_role_binding_list(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_namespaced_role_list_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_namespaced_role_list(_api::RbacAuthorizationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_namespaced_role_list_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_namespaced_role_list(_api::RbacAuthorizationV1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_namespaced_role_list(_api::RbacAuthorizationV1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_role_binding_list_for_all_namespaces_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_role_binding_list_for_all_namespaces_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1_role_list_for_all_namespaces_RbacAuthorizationV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1_role_list_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1_role_list_for_all_namespaces_RbacAuthorizationV1Api, "/apis/rbac.authorization.k8s.io/v1/watch/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1_role_list_for_all_namespaces(_api::RbacAuthorizationV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1_role_list_for_all_namespaces(_api::RbacAuthorizationV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_rbac_authorization_v1_cluster_role -export create_rbac_authorization_v1_cluster_role_binding -export create_rbac_authorization_v1_namespaced_role -export create_rbac_authorization_v1_namespaced_role_binding -export delete_rbac_authorization_v1_cluster_role -export delete_rbac_authorization_v1_cluster_role_binding -export delete_rbac_authorization_v1_collection_cluster_role -export delete_rbac_authorization_v1_collection_cluster_role_binding -export delete_rbac_authorization_v1_collection_namespaced_role -export delete_rbac_authorization_v1_collection_namespaced_role_binding -export delete_rbac_authorization_v1_namespaced_role -export delete_rbac_authorization_v1_namespaced_role_binding -export get_rbac_authorization_v1_a_p_i_resources -export list_rbac_authorization_v1_cluster_role -export list_rbac_authorization_v1_cluster_role_binding -export list_rbac_authorization_v1_namespaced_role -export list_rbac_authorization_v1_namespaced_role_binding -export list_rbac_authorization_v1_role_binding_for_all_namespaces -export list_rbac_authorization_v1_role_for_all_namespaces -export patch_rbac_authorization_v1_cluster_role -export patch_rbac_authorization_v1_cluster_role_binding -export patch_rbac_authorization_v1_namespaced_role -export patch_rbac_authorization_v1_namespaced_role_binding -export read_rbac_authorization_v1_cluster_role -export read_rbac_authorization_v1_cluster_role_binding -export read_rbac_authorization_v1_namespaced_role -export read_rbac_authorization_v1_namespaced_role_binding -export replace_rbac_authorization_v1_cluster_role -export replace_rbac_authorization_v1_cluster_role_binding -export replace_rbac_authorization_v1_namespaced_role -export replace_rbac_authorization_v1_namespaced_role_binding -export watch_rbac_authorization_v1_cluster_role -export watch_rbac_authorization_v1_cluster_role_binding -export watch_rbac_authorization_v1_cluster_role_binding_list -export watch_rbac_authorization_v1_cluster_role_list -export watch_rbac_authorization_v1_namespaced_role -export watch_rbac_authorization_v1_namespaced_role_binding -export watch_rbac_authorization_v1_namespaced_role_binding_list -export watch_rbac_authorization_v1_namespaced_role_list -export watch_rbac_authorization_v1_role_binding_list_for_all_namespaces -export watch_rbac_authorization_v1_role_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_RbacAuthorizationV1alpha1Api.jl b/src/ApiImpl/api/apis/api_RbacAuthorizationV1alpha1Api.jl deleted file mode 100644 index 0ff921a1..00000000 --- a/src/ApiImpl/api/apis/api_RbacAuthorizationV1alpha1Api.jl +++ /dev/null @@ -1,1834 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct RbacAuthorizationV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `RbacAuthorizationV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ RbacAuthorizationV1alpha1Api }) = "http://localhost" - -const _returntypes_create_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRole - -Params: -- body::IoK8sApiRbacV1alpha1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRoleBinding - -Params: -- body::IoK8sApiRbacV1alpha1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Role - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1alpha1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1Role, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a RoleBinding - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1alpha1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1alpha1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRole - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_collection_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_collection_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_collection_cluster_role(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_collection_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_collection_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_collection_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_collection_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_collection_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_rbac_authorization_v1alpha1_a_p_i_resources_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_rbac_authorization_v1alpha1_a_p_i_resources(_api::RbacAuthorizationV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_rbac_authorization_v1alpha1_a_p_i_resources_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_rbac_authorization_v1alpha1_a_p_i_resources(_api::RbacAuthorizationV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_rbac_authorization_v1alpha1_a_p_i_resources(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1ClusterRoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1ClusterRoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1alpha1_role_for_all_namespaces_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1alpha1_role_for_all_namespaces_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1alpha1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRole - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1alpha1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1alpha1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1alpha1Role, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1alpha1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRole - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1alpha1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1alpha1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1alpha1Role, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1alpha1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRole - -Params: -- name::String (required) -- body::IoK8sApiRbacV1alpha1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1alpha1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::IoK8sApiRbacV1alpha1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1alpha1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1alpha1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1Role, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1alpha1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1alpha1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1alpha1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1alpha1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1alpha1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_cluster_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_cluster_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_binding_list_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_binding_list_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_list_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_list(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_cluster_role_list_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_cluster_role_list(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_cluster_role_list(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_namespaced_role(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_binding_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_binding_list_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api::RbacAuthorizationV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_binding_list_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api::RbacAuthorizationV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_list_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_list(_api::RbacAuthorizationV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_namespaced_role_list_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_namespaced_role_list(_api::RbacAuthorizationV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_namespaced_role_list(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces_RbacAuthorizationV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces_RbacAuthorizationV1alpha1Api, "/apis/rbac.authorization.k8s.io/v1alpha1/watch/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api::RbacAuthorizationV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_rbac_authorization_v1alpha1_cluster_role -export create_rbac_authorization_v1alpha1_cluster_role_binding -export create_rbac_authorization_v1alpha1_namespaced_role -export create_rbac_authorization_v1alpha1_namespaced_role_binding -export delete_rbac_authorization_v1alpha1_cluster_role -export delete_rbac_authorization_v1alpha1_cluster_role_binding -export delete_rbac_authorization_v1alpha1_collection_cluster_role -export delete_rbac_authorization_v1alpha1_collection_cluster_role_binding -export delete_rbac_authorization_v1alpha1_collection_namespaced_role -export delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding -export delete_rbac_authorization_v1alpha1_namespaced_role -export delete_rbac_authorization_v1alpha1_namespaced_role_binding -export get_rbac_authorization_v1alpha1_a_p_i_resources -export list_rbac_authorization_v1alpha1_cluster_role -export list_rbac_authorization_v1alpha1_cluster_role_binding -export list_rbac_authorization_v1alpha1_namespaced_role -export list_rbac_authorization_v1alpha1_namespaced_role_binding -export list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces -export list_rbac_authorization_v1alpha1_role_for_all_namespaces -export patch_rbac_authorization_v1alpha1_cluster_role -export patch_rbac_authorization_v1alpha1_cluster_role_binding -export patch_rbac_authorization_v1alpha1_namespaced_role -export patch_rbac_authorization_v1alpha1_namespaced_role_binding -export read_rbac_authorization_v1alpha1_cluster_role -export read_rbac_authorization_v1alpha1_cluster_role_binding -export read_rbac_authorization_v1alpha1_namespaced_role -export read_rbac_authorization_v1alpha1_namespaced_role_binding -export replace_rbac_authorization_v1alpha1_cluster_role -export replace_rbac_authorization_v1alpha1_cluster_role_binding -export replace_rbac_authorization_v1alpha1_namespaced_role -export replace_rbac_authorization_v1alpha1_namespaced_role_binding -export watch_rbac_authorization_v1alpha1_cluster_role -export watch_rbac_authorization_v1alpha1_cluster_role_binding -export watch_rbac_authorization_v1alpha1_cluster_role_binding_list -export watch_rbac_authorization_v1alpha1_cluster_role_list -export watch_rbac_authorization_v1alpha1_namespaced_role -export watch_rbac_authorization_v1alpha1_namespaced_role_binding -export watch_rbac_authorization_v1alpha1_namespaced_role_binding_list -export watch_rbac_authorization_v1alpha1_namespaced_role_list -export watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces -export watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_RbacAuthorizationV1beta1Api.jl b/src/ApiImpl/api/apis/api_RbacAuthorizationV1beta1Api.jl deleted file mode 100644 index 6a82e473..00000000 --- a/src/ApiImpl/api/apis/api_RbacAuthorizationV1beta1Api.jl +++ /dev/null @@ -1,1834 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct RbacAuthorizationV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `RbacAuthorizationV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ RbacAuthorizationV1beta1Api }) = "http://localhost" - -const _returntypes_create_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRole - -Params: -- body::IoK8sApiRbacV1beta1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_cluster_role(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a ClusterRoleBinding - -Params: -- body::IoK8sApiRbacV1beta1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_cluster_role_binding(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a Role - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1beta1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1Role, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_namespaced_role(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a RoleBinding - -Params: -- namespace::String (required) -- body::IoK8sApiRbacV1beta1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function create_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_rbac_authorization_v1beta1_namespaced_role_binding(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRole - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_cluster_role(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_cluster_role_binding(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_collection_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_collection_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_collection_cluster_role(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_collection_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_collection_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_collection_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_collection_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_collection_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_collection_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_collection_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_collection_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_collection_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_rbac_authorization_v1beta1_a_p_i_resources_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_rbac_authorization_v1beta1_a_p_i_resources(_api::RbacAuthorizationV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_rbac_authorization_v1beta1_a_p_i_resources_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_rbac_authorization_v1beta1_a_p_i_resources(_api::RbacAuthorizationV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_rbac_authorization_v1beta1_a_p_i_resources(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_rbac_authorization_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRole - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1ClusterRoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_cluster_role(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind ClusterRoleBinding - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1ClusterRoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_cluster_role_binding(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_namespaced_role(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_namespaced_role_binding(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_role_binding_for_all_namespaces_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBindingList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_role_binding_for_all_namespaces_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind RoleBinding - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1RoleBindingList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_rbac_authorization_v1beta1_role_for_all_namespaces_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_rbac_authorization_v1beta1_role_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_rbac_authorization_v1beta1_role_for_all_namespaces_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind Role - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiRbacV1beta1RoleList, OpenAPI.Clients.ApiResponse -""" -function list_rbac_authorization_v1beta1_role_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_rbac_authorization_v1beta1_role_for_all_namespaces(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_rbac_authorization_v1beta1_role_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRole - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1beta1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1beta1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1beta1Role, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiRbacV1beta1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function patch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRole - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1beta1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_cluster_role(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified ClusterRoleBinding - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiRbacV1beta1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_cluster_role_binding(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1beta1Role, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String - -Return: IoK8sApiRbacV1beta1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function read_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRole, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRole - -Params: -- name::String (required) -- body::IoK8sApiRbacV1beta1ClusterRole (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1ClusterRole, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1beta1ClusterRole; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_cluster_role(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1ClusterRoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified ClusterRoleBinding - -Params: -- name::String (required) -- body::IoK8sApiRbacV1beta1ClusterRoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1ClusterRoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiRbacV1beta1ClusterRoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_cluster_role_binding(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1Role, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/roles/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified Role - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1beta1Role (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1Role, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1beta1Role; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiRbacV1beta1RoleBinding, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified RoleBinding - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiRbacV1beta1RoleBinding (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiRbacV1beta1RoleBinding, OpenAPI.Clients.ApiResponse -""" -function replace_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiRbacV1beta1RoleBinding; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_cluster_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_cluster_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_cluster_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_cluster_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_cluster_role_binding_list_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_cluster_role_binding_list_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_cluster_role_list_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_list(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_cluster_role_list_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_cluster_role_list(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_cluster_role_list(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_cluster_role_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/{namespace}/roles/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_namespaced_role(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_binding_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/{namespace}/rolebindings/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_namespaced_role_binding(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_binding_list_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api::RbacAuthorizationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_binding_list_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/{namespace}/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api::RbacAuthorizationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_list_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_list(_api::RbacAuthorizationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_namespaced_role_list_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/{namespace}/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_namespaced_role_list(_api::RbacAuthorizationV1beta1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_namespaced_role_list(_api::RbacAuthorizationV1beta1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_namespaced_role_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/rolebindings", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_rbac_authorization_v1beta1_role_list_for_all_namespaces_RbacAuthorizationV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_rbac_authorization_v1beta1_role_list_for_all_namespaces_RbacAuthorizationV1beta1Api, "/apis/rbac.authorization.k8s.io/v1beta1/watch/roles", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api::RbacAuthorizationV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_rbac_authorization_v1beta1_cluster_role -export create_rbac_authorization_v1beta1_cluster_role_binding -export create_rbac_authorization_v1beta1_namespaced_role -export create_rbac_authorization_v1beta1_namespaced_role_binding -export delete_rbac_authorization_v1beta1_cluster_role -export delete_rbac_authorization_v1beta1_cluster_role_binding -export delete_rbac_authorization_v1beta1_collection_cluster_role -export delete_rbac_authorization_v1beta1_collection_cluster_role_binding -export delete_rbac_authorization_v1beta1_collection_namespaced_role -export delete_rbac_authorization_v1beta1_collection_namespaced_role_binding -export delete_rbac_authorization_v1beta1_namespaced_role -export delete_rbac_authorization_v1beta1_namespaced_role_binding -export get_rbac_authorization_v1beta1_a_p_i_resources -export list_rbac_authorization_v1beta1_cluster_role -export list_rbac_authorization_v1beta1_cluster_role_binding -export list_rbac_authorization_v1beta1_namespaced_role -export list_rbac_authorization_v1beta1_namespaced_role_binding -export list_rbac_authorization_v1beta1_role_binding_for_all_namespaces -export list_rbac_authorization_v1beta1_role_for_all_namespaces -export patch_rbac_authorization_v1beta1_cluster_role -export patch_rbac_authorization_v1beta1_cluster_role_binding -export patch_rbac_authorization_v1beta1_namespaced_role -export patch_rbac_authorization_v1beta1_namespaced_role_binding -export read_rbac_authorization_v1beta1_cluster_role -export read_rbac_authorization_v1beta1_cluster_role_binding -export read_rbac_authorization_v1beta1_namespaced_role -export read_rbac_authorization_v1beta1_namespaced_role_binding -export replace_rbac_authorization_v1beta1_cluster_role -export replace_rbac_authorization_v1beta1_cluster_role_binding -export replace_rbac_authorization_v1beta1_namespaced_role -export replace_rbac_authorization_v1beta1_namespaced_role_binding -export watch_rbac_authorization_v1beta1_cluster_role -export watch_rbac_authorization_v1beta1_cluster_role_binding -export watch_rbac_authorization_v1beta1_cluster_role_binding_list -export watch_rbac_authorization_v1beta1_cluster_role_list -export watch_rbac_authorization_v1beta1_namespaced_role -export watch_rbac_authorization_v1beta1_namespaced_role_binding -export watch_rbac_authorization_v1beta1_namespaced_role_binding_list -export watch_rbac_authorization_v1beta1_namespaced_role_list -export watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces -export watch_rbac_authorization_v1beta1_role_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_SchedulingApi.jl b/src/ApiImpl/api/apis/api_SchedulingApi.jl deleted file mode 100644 index 6403a51f..00000000 --- a/src/ApiImpl/api/apis/api_SchedulingApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SchedulingApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SchedulingApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SchedulingApi }) = "http://localhost" - -const _returntypes_get_scheduling_a_p_i_group_SchedulingApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_scheduling_a_p_i_group(_api::SchedulingApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_scheduling_a_p_i_group_SchedulingApi, "/apis/scheduling.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_scheduling_a_p_i_group(_api::SchedulingApi; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_scheduling_a_p_i_group(_api::SchedulingApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_scheduling_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_SchedulingV1Api.jl b/src/ApiImpl/api/apis/api_SchedulingV1Api.jl deleted file mode 100644 index 3a2097b7..00000000 --- a/src/ApiImpl/api/apis/api_SchedulingV1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SchedulingV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SchedulingV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SchedulingV1Api }) = "http://localhost" - -const _returntypes_create_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_scheduling_v1_priority_class(_api::SchedulingV1Api, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PriorityClass - -Params: -- body::IoK8sApiSchedulingV1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function create_scheduling_v1_priority_class(_api::SchedulingV1Api, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1_collection_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1_collection_priority_class(_api::SchedulingV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1_collection_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1_collection_priority_class(_api::SchedulingV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1_collection_priority_class(_api::SchedulingV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PriorityClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_scheduling_v1_a_p_i_resources_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_scheduling_v1_a_p_i_resources(_api::SchedulingV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_scheduling_v1_a_p_i_resources_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_scheduling_v1_a_p_i_resources(_api::SchedulingV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_scheduling_v1_a_p_i_resources(_api::SchedulingV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_scheduling_v1_priority_class(_api::SchedulingV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiSchedulingV1PriorityClassList, OpenAPI.Clients.ApiResponse -""" -function list_scheduling_v1_priority_class(_api::SchedulingV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PriorityClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiSchedulingV1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function patch_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PriorityClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiSchedulingV1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function read_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PriorityClass - -Params: -- name::String (required) -- body::IoK8sApiSchedulingV1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function replace_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, name::String, body::IoK8sApiSchedulingV1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1_priority_class_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1_priority_class_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1_priority_class(_api::SchedulingV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1_priority_class(_api::SchedulingV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1_priority_class_list_SchedulingV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1_priority_class_list(_api::SchedulingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1_priority_class_list_SchedulingV1Api, "/apis/scheduling.k8s.io/v1/watch/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1_priority_class_list(_api::SchedulingV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1_priority_class_list(_api::SchedulingV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_scheduling_v1_priority_class -export delete_scheduling_v1_collection_priority_class -export delete_scheduling_v1_priority_class -export get_scheduling_v1_a_p_i_resources -export list_scheduling_v1_priority_class -export patch_scheduling_v1_priority_class -export read_scheduling_v1_priority_class -export replace_scheduling_v1_priority_class -export watch_scheduling_v1_priority_class -export watch_scheduling_v1_priority_class_list diff --git a/src/ApiImpl/api/apis/api_SchedulingV1alpha1Api.jl b/src/ApiImpl/api/apis/api_SchedulingV1alpha1Api.jl deleted file mode 100644 index 1499c6f8..00000000 --- a/src/ApiImpl/api/apis/api_SchedulingV1alpha1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SchedulingV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SchedulingV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SchedulingV1alpha1Api }) = "http://localhost" - -const _returntypes_create_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PriorityClass - -Params: -- body::IoK8sApiSchedulingV1alpha1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1alpha1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function create_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1alpha1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1alpha1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1alpha1_collection_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1alpha1_collection_priority_class(_api::SchedulingV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1alpha1_collection_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1alpha1_collection_priority_class(_api::SchedulingV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1alpha1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1alpha1_collection_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1alpha1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PriorityClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1alpha1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1alpha1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_scheduling_v1alpha1_a_p_i_resources_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_scheduling_v1alpha1_a_p_i_resources(_api::SchedulingV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_scheduling_v1alpha1_a_p_i_resources_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_scheduling_v1alpha1_a_p_i_resources(_api::SchedulingV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_scheduling_v1alpha1_a_p_i_resources(_api::SchedulingV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiSchedulingV1alpha1PriorityClassList, OpenAPI.Clients.ApiResponse -""" -function list_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1alpha1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1alpha1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PriorityClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiSchedulingV1alpha1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function patch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1alpha1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1alpha1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PriorityClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiSchedulingV1alpha1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function read_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1alpha1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1alpha1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1alpha1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PriorityClass - -Params: -- name::String (required) -- body::IoK8sApiSchedulingV1alpha1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1alpha1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function replace_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1alpha1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiSchedulingV1alpha1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1alpha1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1alpha1_priority_class_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1alpha1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1alpha1_priority_class(_api::SchedulingV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1alpha1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1alpha1_priority_class_list_SchedulingV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1alpha1_priority_class_list(_api::SchedulingV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1alpha1_priority_class_list_SchedulingV1alpha1Api, "/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1alpha1_priority_class_list(_api::SchedulingV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1alpha1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1alpha1_priority_class_list(_api::SchedulingV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1alpha1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_scheduling_v1alpha1_priority_class -export delete_scheduling_v1alpha1_collection_priority_class -export delete_scheduling_v1alpha1_priority_class -export get_scheduling_v1alpha1_a_p_i_resources -export list_scheduling_v1alpha1_priority_class -export patch_scheduling_v1alpha1_priority_class -export read_scheduling_v1alpha1_priority_class -export replace_scheduling_v1alpha1_priority_class -export watch_scheduling_v1alpha1_priority_class -export watch_scheduling_v1alpha1_priority_class_list diff --git a/src/ApiImpl/api/apis/api_SchedulingV1beta1Api.jl b/src/ApiImpl/api/apis/api_SchedulingV1beta1Api.jl deleted file mode 100644 index f5c549d6..00000000 --- a/src/ApiImpl/api/apis/api_SchedulingV1beta1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SchedulingV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SchedulingV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SchedulingV1beta1Api }) = "http://localhost" - -const _returntypes_create_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PriorityClass - -Params: -- body::IoK8sApiSchedulingV1beta1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1beta1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function create_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1beta1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_scheduling_v1beta1_priority_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1beta1_collection_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1beta1_collection_priority_class(_api::SchedulingV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1beta1_collection_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1beta1_collection_priority_class(_api::SchedulingV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1beta1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1beta1_collection_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1beta1_collection_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PriorityClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1beta1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_scheduling_v1beta1_priority_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_scheduling_v1beta1_a_p_i_resources_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_scheduling_v1beta1_a_p_i_resources(_api::SchedulingV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_scheduling_v1beta1_a_p_i_resources_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_scheduling_v1beta1_a_p_i_resources(_api::SchedulingV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_scheduling_v1beta1_a_p_i_resources(_api::SchedulingV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_scheduling_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PriorityClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiSchedulingV1beta1PriorityClassList, OpenAPI.Clients.ApiResponse -""" -function list_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1beta1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_scheduling_v1beta1_priority_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PriorityClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiSchedulingV1beta1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function patch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1beta1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_scheduling_v1beta1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PriorityClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiSchedulingV1beta1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function read_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1beta1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_scheduling_v1beta1_priority_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSchedulingV1beta1PriorityClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/priorityclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PriorityClass - -Params: -- name::String (required) -- body::IoK8sApiSchedulingV1beta1PriorityClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSchedulingV1beta1PriorityClass, OpenAPI.Clients.ApiResponse -""" -function replace_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1beta1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiSchedulingV1beta1PriorityClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_scheduling_v1beta1_priority_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1beta1_priority_class_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1beta1_priority_class_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1beta1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1beta1_priority_class(_api::SchedulingV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1beta1_priority_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_scheduling_v1beta1_priority_class_list_SchedulingV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_scheduling_v1beta1_priority_class_list(_api::SchedulingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_scheduling_v1beta1_priority_class_list_SchedulingV1beta1Api, "/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_scheduling_v1beta1_priority_class_list(_api::SchedulingV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1beta1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_scheduling_v1beta1_priority_class_list(_api::SchedulingV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_scheduling_v1beta1_priority_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_scheduling_v1beta1_priority_class -export delete_scheduling_v1beta1_collection_priority_class -export delete_scheduling_v1beta1_priority_class -export get_scheduling_v1beta1_a_p_i_resources -export list_scheduling_v1beta1_priority_class -export patch_scheduling_v1beta1_priority_class -export read_scheduling_v1beta1_priority_class -export replace_scheduling_v1beta1_priority_class -export watch_scheduling_v1beta1_priority_class -export watch_scheduling_v1beta1_priority_class_list diff --git a/src/ApiImpl/api/apis/api_SettingsApi.jl b/src/ApiImpl/api/apis/api_SettingsApi.jl deleted file mode 100644 index c8e7f1ad..00000000 --- a/src/ApiImpl/api/apis/api_SettingsApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SettingsApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SettingsApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SettingsApi }) = "http://localhost" - -const _returntypes_get_settings_a_p_i_group_SettingsApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_settings_a_p_i_group(_api::SettingsApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_settings_a_p_i_group_SettingsApi, "/apis/settings.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_settings_a_p_i_group(_api::SettingsApi; _mediaType=nothing) - _ctx = _oacinternal_get_settings_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_settings_a_p_i_group(_api::SettingsApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_settings_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_settings_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_SettingsV1alpha1Api.jl b/src/ApiImpl/api/apis/api_SettingsV1alpha1Api.jl deleted file mode 100644 index 7a1aecb6..00000000 --- a/src/ApiImpl/api/apis/api_SettingsV1alpha1Api.jl +++ /dev/null @@ -1,550 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct SettingsV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `SettingsV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ SettingsV1alpha1Api }) = "http://localhost" - -const _returntypes_create_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a PodPreset - -Params: -- namespace::String (required) -- body::IoK8sApiSettingsV1alpha1PodPreset (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSettingsV1alpha1PodPreset, OpenAPI.Clients.ApiResponse -""" -function create_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_settings_v1alpha1_namespaced_pod_preset(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_settings_v1alpha1_namespaced_pod_preset(_api, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_settings_v1alpha1_collection_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_settings_v1alpha1_collection_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_settings_v1alpha1_collection_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of PodPreset - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_settings_v1alpha1_collection_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_settings_v1alpha1_collection_namespaced_pod_preset(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_settings_v1alpha1_collection_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_settings_v1alpha1_collection_namespaced_pod_preset(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a PodPreset - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_settings_v1alpha1_a_p_i_resources_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_settings_v1alpha1_a_p_i_resources(_api::SettingsV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_settings_v1alpha1_a_p_i_resources_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_settings_v1alpha1_a_p_i_resources(_api::SettingsV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_settings_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_settings_v1alpha1_a_p_i_resources(_api::SettingsV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_settings_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPresetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodPreset - -Params: -- namespace::String (required) -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiSettingsV1alpha1PodPresetList, OpenAPI.Clients.ApiResponse -""" -function list_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_settings_v1alpha1_namespaced_pod_preset(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, namespace::String; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_settings_v1alpha1_namespaced_pod_preset(_api, namespace; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_settings_v1alpha1_pod_preset_for_all_namespaces_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPresetList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_settings_v1alpha1_pod_preset_for_all_namespaces(_api::SettingsV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_settings_v1alpha1_pod_preset_for_all_namespaces_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/podpresets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind PodPreset - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiSettingsV1alpha1PodPresetList, OpenAPI.Clients.ApiResponse -""" -function list_settings_v1alpha1_pod_preset_for_all_namespaces(_api::SettingsV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_settings_v1alpha1_pod_preset_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_settings_v1alpha1_pod_preset_for_all_namespaces(_api::SettingsV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_settings_v1alpha1_pod_preset_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified PodPreset - -Params: -- name::String (required) -- namespace::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiSettingsV1alpha1PodPreset, OpenAPI.Clients.ApiResponse -""" -function patch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified PodPreset - -Params: -- name::String (required) -- namespace::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiSettingsV1alpha1PodPreset, OpenAPI.Clients.ApiResponse -""" -function read_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, name::String, namespace::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiSettingsV1alpha1PodPreset, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/namespaces/{namespace}/podpresets/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified PodPreset - -Params: -- name::String (required) -- namespace::String (required) -- body::IoK8sApiSettingsV1alpha1PodPreset (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiSettingsV1alpha1PodPreset, OpenAPI.Clients.ApiResponse -""" -function replace_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, name::String, namespace::String, body::IoK8sApiSettingsV1alpha1PodPreset; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_settings_v1alpha1_namespaced_pod_preset_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/watch/namespaces/{namespace}/podpresets/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind PodPreset. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_settings_v1alpha1_namespaced_pod_preset(_api::SettingsV1alpha1Api, response_stream::Channel, name::String, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset(_api, name, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_settings_v1alpha1_namespaced_pod_preset_list_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset_list(_api::SettingsV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_settings_v1alpha1_namespaced_pod_preset_list_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/watch/namespaces/{namespace}/podpresets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "namespace", namespace) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodPreset. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- namespace::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_settings_v1alpha1_namespaced_pod_preset_list(_api::SettingsV1alpha1Api, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_settings_v1alpha1_namespaced_pod_preset_list(_api::SettingsV1alpha1Api, response_stream::Channel, namespace::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_namespaced_pod_preset_list(_api, namespace; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_settings_v1alpha1_pod_preset_list_for_all_namespaces_SettingsV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api::SettingsV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_settings_v1alpha1_pod_preset_list_for_all_namespaces_SettingsV1alpha1Api, "/apis/settings.k8s.io/v1alpha1/watch/podpresets", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of PodPreset. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api::SettingsV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api::SettingsV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_settings_v1alpha1_namespaced_pod_preset -export delete_settings_v1alpha1_collection_namespaced_pod_preset -export delete_settings_v1alpha1_namespaced_pod_preset -export get_settings_v1alpha1_a_p_i_resources -export list_settings_v1alpha1_namespaced_pod_preset -export list_settings_v1alpha1_pod_preset_for_all_namespaces -export patch_settings_v1alpha1_namespaced_pod_preset -export read_settings_v1alpha1_namespaced_pod_preset -export replace_settings_v1alpha1_namespaced_pod_preset -export watch_settings_v1alpha1_namespaced_pod_preset -export watch_settings_v1alpha1_namespaced_pod_preset_list -export watch_settings_v1alpha1_pod_preset_list_for_all_namespaces diff --git a/src/ApiImpl/api/apis/api_StorageApi.jl b/src/ApiImpl/api/apis/api_StorageApi.jl deleted file mode 100644 index 7335037d..00000000 --- a/src/ApiImpl/api/apis/api_StorageApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct StorageApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `StorageApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ StorageApi }) = "http://localhost" - -const _returntypes_get_storage_a_p_i_group_StorageApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIGroup, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_storage_a_p_i_group(_api::StorageApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_storage_a_p_i_group_StorageApi, "/apis/storage.k8s.io/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get information of a group - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIGroup, OpenAPI.Clients.ApiResponse -""" -function get_storage_a_p_i_group(_api::StorageApi; _mediaType=nothing) - _ctx = _oacinternal_get_storage_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_storage_a_p_i_group(_api::StorageApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_storage_a_p_i_group(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_storage_a_p_i_group diff --git a/src/ApiImpl/api/apis/api_StorageV1Api.jl b/src/ApiImpl/api/apis/api_StorageV1Api.jl deleted file mode 100644 index 664ac600..00000000 --- a/src/ApiImpl/api/apis/api_StorageV1Api.jl +++ /dev/null @@ -1,1342 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct StorageV1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `StorageV1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ StorageV1Api }) = "http://localhost" - -const _returntypes_create_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1_c_s_i_node(_api::StorageV1Api, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CSINode - -Params: -- body::IoK8sApiStorageV1CSINode (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1CSINode, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1_c_s_i_node(_api::StorageV1Api, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_c_s_i_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_c_s_i_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1_storage_class(_api::StorageV1Api, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a StorageClass - -Params: -- body::IoK8sApiStorageV1StorageClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1StorageClass, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1_storage_class(_api::StorageV1Api, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_storage_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_storage_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1_volume_attachment(_api::StorageV1Api, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a VolumeAttachment - -Params: -- body::IoK8sApiStorageV1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1_volume_attachment(_api::StorageV1Api, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CSINode - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_c_s_i_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_c_s_i_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_collection_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_collection_c_s_i_node(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_collection_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CSINode - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_collection_c_s_i_node(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_collection_c_s_i_node(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_collection_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_collection_storage_class(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_collection_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of StorageClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_collection_storage_class(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_collection_storage_class(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_collection_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_collection_volume_attachment(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_collection_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_collection_volume_attachment(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_collection_volume_attachment(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_storage_class(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a StorageClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_storage_class(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_storage_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_storage_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1_volume_attachment(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1_volume_attachment(_api::StorageV1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_storage_v1_a_p_i_resources_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_storage_v1_a_p_i_resources(_api::StorageV1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_storage_v1_a_p_i_resources_StorageV1Api, "/apis/storage.k8s.io/v1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_storage_v1_a_p_i_resources(_api::StorageV1Api; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_storage_v1_a_p_i_resources(_api::StorageV1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1CSINodeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1_c_s_i_node(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CSINode - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1CSINodeList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1_c_s_i_node(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1_storage_class(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StorageClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1StorageClassList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1_storage_class(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachmentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1_volume_attachment(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1VolumeAttachmentList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1_volume_attachment(_api::StorageV1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1_c_s_i_node(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CSINode - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1CSINode, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1_c_s_i_node(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1_storage_class(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified StorageClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1StorageClass, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1_storage_class(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1_volume_attachment(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified VolumeAttachment - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1_volume_attachment(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1_volume_attachment_status_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1_volume_attachment_status_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update status of the specified VolumeAttachment - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_volume_attachment_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1_volume_attachment_status(_api::StorageV1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1_volume_attachment_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CSINode - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1CSINode, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_c_s_i_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_c_s_i_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1_storage_class(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified StorageClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1StorageClass, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1_storage_class(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_storage_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_storage_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1_volume_attachment(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1_volume_attachment(_api::StorageV1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1_volume_attachment_status_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1_volume_attachment_status_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read status of the specified VolumeAttachment - -Params: -- name::String (required) -- pretty::String - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_volume_attachment_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1_volume_attachment_status(_api::StorageV1Api, response_stream::Channel, name::String; pretty=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1_volume_attachment_status(_api, name; pretty=pretty, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1_c_s_i_node(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CSINode - -Params: -- name::String (required) -- body::IoK8sApiStorageV1CSINode (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1CSINode, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1_c_s_i_node(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1_storage_class(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified StorageClass - -Params: -- name::String (required) -- body::IoK8sApiStorageV1StorageClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1StorageClass, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1_storage_class(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1_volume_attachment(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified VolumeAttachment - -Params: -- name::String (required) -- body::IoK8sApiStorageV1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1_volume_attachment(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1_volume_attachment_status_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1_volume_attachment_status_StorageV1Api, "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace status of the specified VolumeAttachment - -Params: -- name::String (required) -- body::IoK8sApiStorageV1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1_volume_attachment_status(_api::StorageV1Api, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_volume_attachment_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1_volume_attachment_status(_api::StorageV1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1_volume_attachment_status(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_c_s_i_node_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_c_s_i_node_StorageV1Api, "/apis/storage.k8s.io/v1/watch/csinodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_c_s_i_node(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_c_s_i_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_c_s_i_node(_api::StorageV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_c_s_i_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_c_s_i_node_list_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_c_s_i_node_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_c_s_i_node_list_StorageV1Api, "/apis/storage.k8s.io/v1/watch/csinodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_c_s_i_node_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_c_s_i_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_c_s_i_node_list(_api::StorageV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_c_s_i_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_storage_class_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_storage_class(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_storage_class_StorageV1Api, "/apis/storage.k8s.io/v1/watch/storageclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_storage_class(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_storage_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_storage_class(_api::StorageV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_storage_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_storage_class_list_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_storage_class_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_storage_class_list_StorageV1Api, "/apis/storage.k8s.io/v1/watch/storageclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_storage_class_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_storage_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_storage_class_list(_api::StorageV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_storage_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_volume_attachment_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_volume_attachment(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_volume_attachment_StorageV1Api, "/apis/storage.k8s.io/v1/watch/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_volume_attachment(_api::StorageV1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_volume_attachment(_api::StorageV1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1_volume_attachment_list_StorageV1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1_volume_attachment_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1_volume_attachment_list_StorageV1Api, "/apis/storage.k8s.io/v1/watch/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1_volume_attachment_list(_api::StorageV1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1_volume_attachment_list(_api::StorageV1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_storage_v1_c_s_i_node -export create_storage_v1_storage_class -export create_storage_v1_volume_attachment -export delete_storage_v1_c_s_i_node -export delete_storage_v1_collection_c_s_i_node -export delete_storage_v1_collection_storage_class -export delete_storage_v1_collection_volume_attachment -export delete_storage_v1_storage_class -export delete_storage_v1_volume_attachment -export get_storage_v1_a_p_i_resources -export list_storage_v1_c_s_i_node -export list_storage_v1_storage_class -export list_storage_v1_volume_attachment -export patch_storage_v1_c_s_i_node -export patch_storage_v1_storage_class -export patch_storage_v1_volume_attachment -export patch_storage_v1_volume_attachment_status -export read_storage_v1_c_s_i_node -export read_storage_v1_storage_class -export read_storage_v1_volume_attachment -export read_storage_v1_volume_attachment_status -export replace_storage_v1_c_s_i_node -export replace_storage_v1_storage_class -export replace_storage_v1_volume_attachment -export replace_storage_v1_volume_attachment_status -export watch_storage_v1_c_s_i_node -export watch_storage_v1_c_s_i_node_list -export watch_storage_v1_storage_class -export watch_storage_v1_storage_class_list -export watch_storage_v1_volume_attachment -export watch_storage_v1_volume_attachment_list diff --git a/src/ApiImpl/api/apis/api_StorageV1alpha1Api.jl b/src/ApiImpl/api/apis/api_StorageV1alpha1Api.jl deleted file mode 100644 index b59c894e..00000000 --- a/src/ApiImpl/api/apis/api_StorageV1alpha1Api.jl +++ /dev/null @@ -1,438 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct StorageV1alpha1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `StorageV1alpha1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ StorageV1alpha1Api }) = "http://localhost" - -const _returntypes_create_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a VolumeAttachment - -Params: -- body::IoK8sApiStorageV1alpha1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1alpha1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1alpha1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1alpha1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1alpha1_collection_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1alpha1_collection_volume_attachment(_api::StorageV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1alpha1_collection_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1alpha1_collection_volume_attachment(_api::StorageV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1alpha1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1alpha1_collection_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1alpha1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1alpha1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1alpha1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_storage_v1alpha1_a_p_i_resources_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_storage_v1alpha1_a_p_i_resources(_api::StorageV1alpha1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_storage_v1alpha1_a_p_i_resources_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_storage_v1alpha1_a_p_i_resources(_api::StorageV1alpha1Api; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_storage_v1alpha1_a_p_i_resources(_api::StorageV1alpha1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1alpha1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachmentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1alpha1VolumeAttachmentList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1alpha1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1alpha1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified VolumeAttachment - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1alpha1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1alpha1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1alpha1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1alpha1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1alpha1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1alpha1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1alpha1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified VolumeAttachment - -Params: -- name::String (required) -- body::IoK8sApiStorageV1alpha1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1alpha1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1alpha1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1alpha1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1alpha1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1alpha1_volume_attachment_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1alpha1_volume_attachment_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/watch/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1alpha1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1alpha1_volume_attachment(_api::StorageV1alpha1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1alpha1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1alpha1_volume_attachment_list_StorageV1alpha1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1alpha1_volume_attachment_list(_api::StorageV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1alpha1_volume_attachment_list_StorageV1alpha1Api, "/apis/storage.k8s.io/v1alpha1/watch/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1alpha1_volume_attachment_list(_api::StorageV1alpha1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1alpha1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1alpha1_volume_attachment_list(_api::StorageV1alpha1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1alpha1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_storage_v1alpha1_volume_attachment -export delete_storage_v1alpha1_collection_volume_attachment -export delete_storage_v1alpha1_volume_attachment -export get_storage_v1alpha1_a_p_i_resources -export list_storage_v1alpha1_volume_attachment -export patch_storage_v1alpha1_volume_attachment -export read_storage_v1alpha1_volume_attachment -export replace_storage_v1alpha1_volume_attachment -export watch_storage_v1alpha1_volume_attachment -export watch_storage_v1alpha1_volume_attachment_list diff --git a/src/ApiImpl/api/apis/api_StorageV1beta1Api.jl b/src/ApiImpl/api/apis/api_StorageV1beta1Api.jl deleted file mode 100644 index 48b703b1..00000000 --- a/src/ApiImpl/api/apis/api_StorageV1beta1Api.jl +++ /dev/null @@ -1,1626 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct StorageV1beta1Api <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `StorageV1beta1Api`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ StorageV1beta1Api }) = "http://localhost" - -const _returntypes_create_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CSIDriver - -Params: -- body::IoK8sApiStorageV1beta1CSIDriver (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1CSIDriver, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_c_s_i_driver(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_c_s_i_driver(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a CSINode - -Params: -- body::IoK8sApiStorageV1beta1CSINode (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1CSINode, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_c_s_i_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_c_s_i_node(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1beta1_storage_class(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a StorageClass - -Params: -- body::IoK8sApiStorageV1beta1StorageClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1StorageClass, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1beta1_storage_class(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_storage_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_storage_class(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_create_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_create_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "POST", _returntypes_create_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""create a VolumeAttachment - -Params: -- body::IoK8sApiStorageV1beta1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function create_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function create_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_create_storage_v1beta1_volume_attachment(_api, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CSIDriver - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_c_s_i_driver(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_c_s_i_driver(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a CSINode - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_c_s_i_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_c_s_i_node(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_collection_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_collection_c_s_i_driver(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_collection_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CSIDriver - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_collection_c_s_i_driver(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_c_s_i_driver(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_collection_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_c_s_i_driver(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_collection_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_collection_c_s_i_node(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_collection_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of CSINode - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_collection_c_s_i_node(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_collection_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_collection_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_collection_storage_class(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_collection_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of StorageClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_collection_storage_class(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_collection_storage_class(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_collection_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_collection_volume_attachment(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_collection_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete collection of VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- dry_run::String -- field_selector::String -- grace_period_seconds::Int64 -- label_selector::String -- limit::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_collection_volume_attachment(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_collection_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, dry_run=nothing, field_selector=nothing, grace_period_seconds=nothing, label_selector=nothing, limit=nothing, orphan_dependents=nothing, propagation_policy=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_collection_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, dry_run=dry_run, field_selector=field_selector, grace_period_seconds=grace_period_seconds, label_selector=label_selector, limit=limit, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a StorageClass - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_storage_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_storage_class(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_delete_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("202", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1Status, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_delete_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "DELETE", _returntypes_delete_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "gracePeriodSeconds", grace_period_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "orphanDependents", orphan_dependents) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "propagationPolicy", propagation_policy) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""delete a VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- dry_run::String -- grace_period_seconds::Int64 -- orphan_dependents::Bool -- propagation_policy::String -- body::IoK8sApimachineryPkgApisMetaV1DeleteOptions - -Return: IoK8sApimachineryPkgApisMetaV1Status, OpenAPI.Clients.ApiResponse -""" -function delete_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function delete_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, dry_run=nothing, grace_period_seconds=nothing, orphan_dependents=nothing, propagation_policy=nothing, body=nothing, _mediaType=nothing) - _ctx = _oacinternal_delete_storage_v1beta1_volume_attachment(_api, name; pretty=pretty, dry_run=dry_run, grace_period_seconds=grace_period_seconds, orphan_dependents=orphan_dependents, propagation_policy=propagation_policy, body=body, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_get_storage_v1beta1_a_p_i_resources_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1APIResourceList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_storage_v1beta1_a_p_i_resources(_api::StorageV1beta1Api; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_storage_v1beta1_a_p_i_resources_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get available resources - -Params: - -Return: IoK8sApimachineryPkgApisMetaV1APIResourceList, OpenAPI.Clients.ApiResponse -""" -function get_storage_v1beta1_a_p_i_resources(_api::StorageV1beta1Api; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_storage_v1beta1_a_p_i_resources(_api::StorageV1beta1Api, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_storage_v1beta1_a_p_i_resources(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriverList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CSIDriver - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1beta1CSIDriverList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_c_s_i_driver(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_c_s_i_driver(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINodeList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind CSINode - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1beta1CSINodeList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_c_s_i_node(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClassList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1beta1_storage_class(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind StorageClass - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1beta1StorageClassList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1beta1_storage_class(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_storage_class(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_list_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachmentList, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_list_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_list_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""list or watch objects of kind VolumeAttachment - -Params: -- pretty::String -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApiStorageV1beta1VolumeAttachmentList, OpenAPI.Clients.ApiResponse -""" -function list_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function list_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel; pretty=nothing, allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_list_storage_v1beta1_volume_attachment(_api; pretty=pretty, allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CSIDriver - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1beta1CSIDriver, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_c_s_i_driver(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_c_s_i_driver(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified CSINode - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1beta1CSINode, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified StorageClass - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1beta1StorageClass, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_patch_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_patch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PATCH", _returntypes_patch_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_param(_ctx.query, "force", force) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? ["application/json-patch+json", "application/merge-patch+json", "application/strategic-merge-patch+json", "application/apply-patch+yaml", ] : [_mediaType]) - return _ctx -end - -@doc raw"""partially update the specified VolumeAttachment - -Params: -- name::String (required) -- body::Any (required) -- pretty::String -- dry_run::String -- field_manager::String -- force::Bool - -Return: IoK8sApiStorageV1beta1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function patch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function patch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::Any; pretty=nothing, dry_run=nothing, field_manager=nothing, force=nothing, _mediaType=nothing) - _ctx = _oacinternal_patch_storage_v1beta1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, force=force, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CSIDriver - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1beta1CSIDriver, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_c_s_i_driver(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_c_s_i_driver(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified CSINode - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1beta1CSINode, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_c_s_i_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_c_s_i_node(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified StorageClass - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1beta1StorageClass, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_storage_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_storage_class(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_read_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_read_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_read_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "exact", exact) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "export", __export__) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""read the specified VolumeAttachment - -Params: -- name::String (required) -- pretty::String -- exact::Bool -- __export__::Bool - -Return: IoK8sApiStorageV1beta1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function read_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function read_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, name::String; pretty=nothing, exact=nothing, __export__=nothing, _mediaType=nothing) - _ctx = _oacinternal_read_storage_v1beta1_volume_attachment(_api, name; pretty=pretty, exact=exact, __export__=__export__, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSIDriver, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csidrivers/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CSIDriver - -Params: -- name::String (required) -- body::IoK8sApiStorageV1beta1CSIDriver (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1CSIDriver, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_c_s_i_driver(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1beta1CSIDriver; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_c_s_i_driver(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1CSINode, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/csinodes/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified CSINode - -Params: -- name::String (required) -- body::IoK8sApiStorageV1beta1CSINode (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1CSINode, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1beta1CSINode; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_c_s_i_node(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1StorageClass, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/storageclasses/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified StorageClass - -Params: -- name::String (required) -- body::IoK8sApiStorageV1beta1StorageClass (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1StorageClass, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1beta1StorageClass; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_storage_class(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_replace_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("201", "x"=>".") * "\$") => IoK8sApiStorageV1beta1VolumeAttachment, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_replace_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "PUT", _returntypes_replace_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/volumeattachments/{name}", ["BearerToken", ], body) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "dryRun", dry_run) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldManager", field_manager) # type String - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""replace the specified VolumeAttachment - -Params: -- name::String (required) -- body::IoK8sApiStorageV1beta1VolumeAttachment (required) -- pretty::String -- dry_run::String -- field_manager::String - -Return: IoK8sApiStorageV1beta1VolumeAttachment, OpenAPI.Clients.ApiResponse -""" -function replace_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function replace_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, name::String, body::IoK8sApiStorageV1beta1VolumeAttachment; pretty=nothing, dry_run=nothing, field_manager=nothing, _mediaType=nothing) - _ctx = _oacinternal_replace_storage_v1beta1_volume_attachment(_api, name, body; pretty=pretty, dry_run=dry_run, field_manager=field_manager, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_c_s_i_driver_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_c_s_i_driver_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/csidrivers/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_driver(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_c_s_i_driver(_api::StorageV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_driver(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_c_s_i_driver_list_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_c_s_i_driver_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_c_s_i_driver_list_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/csidrivers", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_c_s_i_driver_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_driver_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_c_s_i_driver_list(_api::StorageV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_driver_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_c_s_i_node_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_c_s_i_node_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/csinodes/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_c_s_i_node(_api::StorageV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_node(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_c_s_i_node_list_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_c_s_i_node_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_c_s_i_node_list_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/csinodes", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_c_s_i_node_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_c_s_i_node_list(_api::StorageV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_c_s_i_node_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_storage_class_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_storage_class_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/storageclasses/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_storage_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_storage_class(_api::StorageV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_storage_class(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_storage_class_list_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_storage_class_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_storage_class_list_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/storageclasses", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_storage_class_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_storage_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_storage_class_list(_api::StorageV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_storage_class_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_volume_attachment_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_volume_attachment_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/volumeattachments/{name}", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.path, "name", name) # type String - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. - -Params: -- name::String (required) -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_volume_attachment(_api::StorageV1beta1Api, response_stream::Channel, name::String; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_volume_attachment(_api, name; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -const _returntypes_watch_storage_v1beta1_volume_attachment_list_StorageV1beta1Api = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgApisMetaV1WatchEvent, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_watch_storage_v1beta1_volume_attachment_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_watch_storage_v1beta1_volume_attachment_list_StorageV1beta1Api, "/apis/storage.k8s.io/v1beta1/watch/volumeattachments", ["BearerToken", ]) - OpenAPI.Clients.set_param(_ctx.query, "allowWatchBookmarks", allow_watch_bookmarks) # type Bool - OpenAPI.Clients.set_param(_ctx.query, "continue", __continue__) # type String - OpenAPI.Clients.set_param(_ctx.query, "fieldSelector", field_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "labelSelector", label_selector) # type String - OpenAPI.Clients.set_param(_ctx.query, "limit", limit) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "pretty", pretty) # type String - OpenAPI.Clients.set_param(_ctx.query, "resourceVersion", resource_version) # type String - OpenAPI.Clients.set_param(_ctx.query, "timeoutSeconds", timeout_seconds) # type Int64 - OpenAPI.Clients.set_param(_ctx.query, "watch", watch) # type Bool - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", "application/yaml", "application/vnd.kubernetes.protobuf", "application/json;stream=watch", "application/vnd.kubernetes.protobuf;stream=watch", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. - -Params: -- allow_watch_bookmarks::Bool -- __continue__::String -- field_selector::String -- label_selector::String -- limit::Int64 -- pretty::String -- resource_version::String -- timeout_seconds::Int64 -- watch::Bool - -Return: IoK8sApimachineryPkgApisMetaV1WatchEvent, OpenAPI.Clients.ApiResponse -""" -function watch_storage_v1beta1_volume_attachment_list(_api::StorageV1beta1Api; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function watch_storage_v1beta1_volume_attachment_list(_api::StorageV1beta1Api, response_stream::Channel; allow_watch_bookmarks=nothing, __continue__=nothing, field_selector=nothing, label_selector=nothing, limit=nothing, pretty=nothing, resource_version=nothing, timeout_seconds=nothing, watch=nothing, _mediaType=nothing) - _ctx = _oacinternal_watch_storage_v1beta1_volume_attachment_list(_api; allow_watch_bookmarks=allow_watch_bookmarks, __continue__=__continue__, field_selector=field_selector, label_selector=label_selector, limit=limit, pretty=pretty, resource_version=resource_version, timeout_seconds=timeout_seconds, watch=watch, _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export create_storage_v1beta1_c_s_i_driver -export create_storage_v1beta1_c_s_i_node -export create_storage_v1beta1_storage_class -export create_storage_v1beta1_volume_attachment -export delete_storage_v1beta1_c_s_i_driver -export delete_storage_v1beta1_c_s_i_node -export delete_storage_v1beta1_collection_c_s_i_driver -export delete_storage_v1beta1_collection_c_s_i_node -export delete_storage_v1beta1_collection_storage_class -export delete_storage_v1beta1_collection_volume_attachment -export delete_storage_v1beta1_storage_class -export delete_storage_v1beta1_volume_attachment -export get_storage_v1beta1_a_p_i_resources -export list_storage_v1beta1_c_s_i_driver -export list_storage_v1beta1_c_s_i_node -export list_storage_v1beta1_storage_class -export list_storage_v1beta1_volume_attachment -export patch_storage_v1beta1_c_s_i_driver -export patch_storage_v1beta1_c_s_i_node -export patch_storage_v1beta1_storage_class -export patch_storage_v1beta1_volume_attachment -export read_storage_v1beta1_c_s_i_driver -export read_storage_v1beta1_c_s_i_node -export read_storage_v1beta1_storage_class -export read_storage_v1beta1_volume_attachment -export replace_storage_v1beta1_c_s_i_driver -export replace_storage_v1beta1_c_s_i_node -export replace_storage_v1beta1_storage_class -export replace_storage_v1beta1_volume_attachment -export watch_storage_v1beta1_c_s_i_driver -export watch_storage_v1beta1_c_s_i_driver_list -export watch_storage_v1beta1_c_s_i_node -export watch_storage_v1beta1_c_s_i_node_list -export watch_storage_v1beta1_storage_class -export watch_storage_v1beta1_storage_class_list -export watch_storage_v1beta1_volume_attachment -export watch_storage_v1beta1_volume_attachment_list diff --git a/src/ApiImpl/api/apis/api_VersionApi.jl b/src/ApiImpl/api/apis/api_VersionApi.jl deleted file mode 100644 index 8b3c58bc..00000000 --- a/src/ApiImpl/api/apis/api_VersionApi.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -struct VersionApi <: OpenAPI.APIClientImpl - client::OpenAPI.Clients.Client -end - -""" -The default API base path for APIs in `VersionApi`. -This can be used to construct the `OpenAPI.Clients.Client` instance. -""" -basepath(::Type{ VersionApi }) = "http://localhost" - -const _returntypes_get_code_version_VersionApi = Dict{Regex,Type}( - Regex("^" * replace("200", "x"=>".") * "\$") => IoK8sApimachineryPkgVersionInfo, - Regex("^" * replace("401", "x"=>".") * "\$") => Nothing, -) - -function _oacinternal_get_code_version(_api::VersionApi; _mediaType=nothing) - _ctx = OpenAPI.Clients.Ctx(_api.client, "GET", _returntypes_get_code_version_VersionApi, "/version/", ["BearerToken", ]) - OpenAPI.Clients.set_header_accept(_ctx, ["application/json", ]) - OpenAPI.Clients.set_header_content_type(_ctx, (_mediaType === nothing) ? [] : [_mediaType]) - return _ctx -end - -@doc raw"""get the code version - -Params: - -Return: IoK8sApimachineryPkgVersionInfo, OpenAPI.Clients.ApiResponse -""" -function get_code_version(_api::VersionApi; _mediaType=nothing) - _ctx = _oacinternal_get_code_version(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx) -end - -function get_code_version(_api::VersionApi, response_stream::Channel; _mediaType=nothing) - _ctx = _oacinternal_get_code_version(_api; _mediaType=_mediaType) - return OpenAPI.Clients.exec(_ctx, response_stream) -end - -export get_code_version diff --git a/src/ApiImpl/api/modelincludes.jl b/src/ApiImpl/api/modelincludes.jl deleted file mode 100644 index c7ee9c96..00000000 --- a/src/ApiImpl/api/modelincludes.jl +++ /dev/null @@ -1,701 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - -include("models/model_IoK8sApiAdmissionregistrationV1MutatingWebhook.jl") -include("models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration.jl") -include("models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList.jl") -include("models/model_IoK8sApiAdmissionregistrationV1RuleWithOperations.jl") -include("models/model_IoK8sApiAdmissionregistrationV1ServiceReference.jl") -include("models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhook.jl") -include("models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration.jl") -include("models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList.jl") -include("models/model_IoK8sApiAdmissionregistrationV1WebhookClientConfig.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1ServiceReference.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList.jl") -include("models/model_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig.jl") -include("models/model_IoK8sApiAppsV1ControllerRevision.jl") -include("models/model_IoK8sApiAppsV1ControllerRevisionList.jl") -include("models/model_IoK8sApiAppsV1DaemonSet.jl") -include("models/model_IoK8sApiAppsV1DaemonSetCondition.jl") -include("models/model_IoK8sApiAppsV1DaemonSetList.jl") -include("models/model_IoK8sApiAppsV1DaemonSetSpec.jl") -include("models/model_IoK8sApiAppsV1DaemonSetStatus.jl") -include("models/model_IoK8sApiAppsV1DaemonSetUpdateStrategy.jl") -include("models/model_IoK8sApiAppsV1Deployment.jl") -include("models/model_IoK8sApiAppsV1DeploymentCondition.jl") -include("models/model_IoK8sApiAppsV1DeploymentList.jl") -include("models/model_IoK8sApiAppsV1DeploymentSpec.jl") -include("models/model_IoK8sApiAppsV1DeploymentStatus.jl") -include("models/model_IoK8sApiAppsV1DeploymentStrategy.jl") -include("models/model_IoK8sApiAppsV1ReplicaSet.jl") -include("models/model_IoK8sApiAppsV1ReplicaSetCondition.jl") -include("models/model_IoK8sApiAppsV1ReplicaSetList.jl") -include("models/model_IoK8sApiAppsV1ReplicaSetSpec.jl") -include("models/model_IoK8sApiAppsV1ReplicaSetStatus.jl") -include("models/model_IoK8sApiAppsV1RollingUpdateDaemonSet.jl") -include("models/model_IoK8sApiAppsV1RollingUpdateDeployment.jl") -include("models/model_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy.jl") -include("models/model_IoK8sApiAppsV1StatefulSet.jl") -include("models/model_IoK8sApiAppsV1StatefulSetCondition.jl") -include("models/model_IoK8sApiAppsV1StatefulSetList.jl") -include("models/model_IoK8sApiAppsV1StatefulSetSpec.jl") -include("models/model_IoK8sApiAppsV1StatefulSetStatus.jl") -include("models/model_IoK8sApiAppsV1StatefulSetUpdateStrategy.jl") -include("models/model_IoK8sApiAppsV1beta1ControllerRevision.jl") -include("models/model_IoK8sApiAppsV1beta1ControllerRevisionList.jl") -include("models/model_IoK8sApiAppsV1beta1Deployment.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentCondition.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentList.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentRollback.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentSpec.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentStatus.jl") -include("models/model_IoK8sApiAppsV1beta1DeploymentStrategy.jl") -include("models/model_IoK8sApiAppsV1beta1RollbackConfig.jl") -include("models/model_IoK8sApiAppsV1beta1RollingUpdateDeployment.jl") -include("models/model_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy.jl") -include("models/model_IoK8sApiAppsV1beta1Scale.jl") -include("models/model_IoK8sApiAppsV1beta1ScaleSpec.jl") -include("models/model_IoK8sApiAppsV1beta1ScaleStatus.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSet.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSetCondition.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSetList.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSetSpec.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSetStatus.jl") -include("models/model_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy.jl") -include("models/model_IoK8sApiAppsV1beta2ControllerRevision.jl") -include("models/model_IoK8sApiAppsV1beta2ControllerRevisionList.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSet.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSetCondition.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSetList.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSetSpec.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSetStatus.jl") -include("models/model_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy.jl") -include("models/model_IoK8sApiAppsV1beta2Deployment.jl") -include("models/model_IoK8sApiAppsV1beta2DeploymentCondition.jl") -include("models/model_IoK8sApiAppsV1beta2DeploymentList.jl") -include("models/model_IoK8sApiAppsV1beta2DeploymentSpec.jl") -include("models/model_IoK8sApiAppsV1beta2DeploymentStatus.jl") -include("models/model_IoK8sApiAppsV1beta2DeploymentStrategy.jl") -include("models/model_IoK8sApiAppsV1beta2ReplicaSet.jl") -include("models/model_IoK8sApiAppsV1beta2ReplicaSetCondition.jl") -include("models/model_IoK8sApiAppsV1beta2ReplicaSetList.jl") -include("models/model_IoK8sApiAppsV1beta2ReplicaSetSpec.jl") -include("models/model_IoK8sApiAppsV1beta2ReplicaSetStatus.jl") -include("models/model_IoK8sApiAppsV1beta2RollingUpdateDaemonSet.jl") -include("models/model_IoK8sApiAppsV1beta2RollingUpdateDeployment.jl") -include("models/model_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy.jl") -include("models/model_IoK8sApiAppsV1beta2Scale.jl") -include("models/model_IoK8sApiAppsV1beta2ScaleSpec.jl") -include("models/model_IoK8sApiAppsV1beta2ScaleStatus.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSet.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSetCondition.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSetList.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSetSpec.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSetStatus.jl") -include("models/model_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1AuditSink.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkList.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1Policy.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1ServiceReference.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1Webhook.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig.jl") -include("models/model_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig.jl") -include("models/model_IoK8sApiAuthenticationV1BoundObjectReference.jl") -include("models/model_IoK8sApiAuthenticationV1TokenRequest.jl") -include("models/model_IoK8sApiAuthenticationV1TokenRequestSpec.jl") -include("models/model_IoK8sApiAuthenticationV1TokenRequestStatus.jl") -include("models/model_IoK8sApiAuthenticationV1TokenReview.jl") -include("models/model_IoK8sApiAuthenticationV1TokenReviewSpec.jl") -include("models/model_IoK8sApiAuthenticationV1TokenReviewStatus.jl") -include("models/model_IoK8sApiAuthenticationV1UserInfo.jl") -include("models/model_IoK8sApiAuthenticationV1beta1TokenReview.jl") -include("models/model_IoK8sApiAuthenticationV1beta1TokenReviewSpec.jl") -include("models/model_IoK8sApiAuthenticationV1beta1TokenReviewStatus.jl") -include("models/model_IoK8sApiAuthenticationV1beta1UserInfo.jl") -include("models/model_IoK8sApiAuthorizationV1LocalSubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1NonResourceAttributes.jl") -include("models/model_IoK8sApiAuthorizationV1NonResourceRule.jl") -include("models/model_IoK8sApiAuthorizationV1ResourceAttributes.jl") -include("models/model_IoK8sApiAuthorizationV1ResourceRule.jl") -include("models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReview.jl") -include("models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1SubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1SubjectAccessReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1SubjectAccessReviewStatus.jl") -include("models/model_IoK8sApiAuthorizationV1SubjectRulesReviewStatus.jl") -include("models/model_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1beta1NonResourceAttributes.jl") -include("models/model_IoK8sApiAuthorizationV1beta1NonResourceRule.jl") -include("models/model_IoK8sApiAuthorizationV1beta1ResourceAttributes.jl") -include("models/model_IoK8sApiAuthorizationV1beta1ResourceRule.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReview.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus.jl") -include("models/model_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus.jl") -include("models/model_IoK8sApiAutoscalingV1CrossVersionObjectReference.jl") -include("models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscaler.jl") -include("models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList.jl") -include("models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec.jl") -include("models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus.jl") -include("models/model_IoK8sApiAutoscalingV1Scale.jl") -include("models/model_IoK8sApiAutoscalingV1ScaleSpec.jl") -include("models/model_IoK8sApiAutoscalingV1ScaleStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ExternalMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ExternalMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler.jl") -include("models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition.jl") -include("models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList.jl") -include("models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec.jl") -include("models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1MetricSpec.jl") -include("models/model_IoK8sApiAutoscalingV2beta1MetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ObjectMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ObjectMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1PodsMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta1PodsMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ResourceMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta1ResourceMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ExternalMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ExternalMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler.jl") -include("models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition.jl") -include("models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList.jl") -include("models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec.jl") -include("models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2MetricIdentifier.jl") -include("models/model_IoK8sApiAutoscalingV2beta2MetricSpec.jl") -include("models/model_IoK8sApiAutoscalingV2beta2MetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2MetricTarget.jl") -include("models/model_IoK8sApiAutoscalingV2beta2MetricValueStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ObjectMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ObjectMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2PodsMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta2PodsMetricStatus.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ResourceMetricSource.jl") -include("models/model_IoK8sApiAutoscalingV2beta2ResourceMetricStatus.jl") -include("models/model_IoK8sApiBatchV1CronJob.jl") -include("models/model_IoK8sApiBatchV1CronJobList.jl") -include("models/model_IoK8sApiBatchV1CronJobSpec.jl") -include("models/model_IoK8sApiBatchV1CronJobStatus.jl") -include("models/model_IoK8sApiBatchV1Job.jl") -include("models/model_IoK8sApiBatchV1JobCondition.jl") -include("models/model_IoK8sApiBatchV1JobList.jl") -include("models/model_IoK8sApiBatchV1JobSpec.jl") -include("models/model_IoK8sApiBatchV1JobStatus.jl") -include("models/model_IoK8sApiBatchV1JobTemplateSpec.jl") -include("models/model_IoK8sApiBatchV1beta1CronJob.jl") -include("models/model_IoK8sApiBatchV1beta1CronJobList.jl") -include("models/model_IoK8sApiBatchV1beta1CronJobSpec.jl") -include("models/model_IoK8sApiBatchV1beta1CronJobStatus.jl") -include("models/model_IoK8sApiBatchV1beta1JobTemplateSpec.jl") -include("models/model_IoK8sApiBatchV2alpha1CronJob.jl") -include("models/model_IoK8sApiBatchV2alpha1CronJobList.jl") -include("models/model_IoK8sApiBatchV2alpha1CronJobSpec.jl") -include("models/model_IoK8sApiBatchV2alpha1CronJobStatus.jl") -include("models/model_IoK8sApiBatchV2alpha1JobTemplateSpec.jl") -include("models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequest.jl") -include("models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition.jl") -include("models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestList.jl") -include("models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec.jl") -include("models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus.jl") -include("models/model_IoK8sApiCoordinationV1Lease.jl") -include("models/model_IoK8sApiCoordinationV1LeaseList.jl") -include("models/model_IoK8sApiCoordinationV1LeaseSpec.jl") -include("models/model_IoK8sApiCoordinationV1beta1Lease.jl") -include("models/model_IoK8sApiCoordinationV1beta1LeaseList.jl") -include("models/model_IoK8sApiCoordinationV1beta1LeaseSpec.jl") -include("models/model_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Affinity.jl") -include("models/model_IoK8sApiCoreV1AttachedVolume.jl") -include("models/model_IoK8sApiCoreV1AzureDiskVolumeSource.jl") -include("models/model_IoK8sApiCoreV1AzureFilePersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1AzureFileVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Binding.jl") -include("models/model_IoK8sApiCoreV1CSIPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1CSIVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Capabilities.jl") -include("models/model_IoK8sApiCoreV1CephFSPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1CephFSVolumeSource.jl") -include("models/model_IoK8sApiCoreV1CinderPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1CinderVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ClientIPConfig.jl") -include("models/model_IoK8sApiCoreV1ComponentCondition.jl") -include("models/model_IoK8sApiCoreV1ComponentStatus.jl") -include("models/model_IoK8sApiCoreV1ComponentStatusList.jl") -include("models/model_IoK8sApiCoreV1ConfigMap.jl") -include("models/model_IoK8sApiCoreV1ConfigMapEnvSource.jl") -include("models/model_IoK8sApiCoreV1ConfigMapKeySelector.jl") -include("models/model_IoK8sApiCoreV1ConfigMapList.jl") -include("models/model_IoK8sApiCoreV1ConfigMapNodeConfigSource.jl") -include("models/model_IoK8sApiCoreV1ConfigMapProjection.jl") -include("models/model_IoK8sApiCoreV1ConfigMapVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Container.jl") -include("models/model_IoK8sApiCoreV1ContainerImage.jl") -include("models/model_IoK8sApiCoreV1ContainerPort.jl") -include("models/model_IoK8sApiCoreV1ContainerState.jl") -include("models/model_IoK8sApiCoreV1ContainerStateRunning.jl") -include("models/model_IoK8sApiCoreV1ContainerStateTerminated.jl") -include("models/model_IoK8sApiCoreV1ContainerStateWaiting.jl") -include("models/model_IoK8sApiCoreV1ContainerStatus.jl") -include("models/model_IoK8sApiCoreV1DaemonEndpoint.jl") -include("models/model_IoK8sApiCoreV1DownwardAPIProjection.jl") -include("models/model_IoK8sApiCoreV1DownwardAPIVolumeFile.jl") -include("models/model_IoK8sApiCoreV1DownwardAPIVolumeSource.jl") -include("models/model_IoK8sApiCoreV1EmptyDirVolumeSource.jl") -include("models/model_IoK8sApiCoreV1EndpointAddress.jl") -include("models/model_IoK8sApiCoreV1EndpointPort.jl") -include("models/model_IoK8sApiCoreV1EndpointSubset.jl") -include("models/model_IoK8sApiCoreV1Endpoints.jl") -include("models/model_IoK8sApiCoreV1EndpointsList.jl") -include("models/model_IoK8sApiCoreV1EnvFromSource.jl") -include("models/model_IoK8sApiCoreV1EnvVar.jl") -include("models/model_IoK8sApiCoreV1EnvVarSource.jl") -include("models/model_IoK8sApiCoreV1EphemeralContainer.jl") -include("models/model_IoK8sApiCoreV1Event.jl") -include("models/model_IoK8sApiCoreV1EventList.jl") -include("models/model_IoK8sApiCoreV1EventSeries.jl") -include("models/model_IoK8sApiCoreV1EventSource.jl") -include("models/model_IoK8sApiCoreV1ExecAction.jl") -include("models/model_IoK8sApiCoreV1FCVolumeSource.jl") -include("models/model_IoK8sApiCoreV1FlexPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1FlexVolumeSource.jl") -include("models/model_IoK8sApiCoreV1FlockerVolumeSource.jl") -include("models/model_IoK8sApiCoreV1GCEPersistentDiskVolumeSource.jl") -include("models/model_IoK8sApiCoreV1GitRepoVolumeSource.jl") -include("models/model_IoK8sApiCoreV1GlusterfsPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1GlusterfsVolumeSource.jl") -include("models/model_IoK8sApiCoreV1HTTPGetAction.jl") -include("models/model_IoK8sApiCoreV1HTTPHeader.jl") -include("models/model_IoK8sApiCoreV1Handler.jl") -include("models/model_IoK8sApiCoreV1HostAlias.jl") -include("models/model_IoK8sApiCoreV1HostPathVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ISCSIPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ISCSIVolumeSource.jl") -include("models/model_IoK8sApiCoreV1KeyToPath.jl") -include("models/model_IoK8sApiCoreV1Lifecycle.jl") -include("models/model_IoK8sApiCoreV1LimitRange.jl") -include("models/model_IoK8sApiCoreV1LimitRangeItem.jl") -include("models/model_IoK8sApiCoreV1LimitRangeList.jl") -include("models/model_IoK8sApiCoreV1LimitRangeSpec.jl") -include("models/model_IoK8sApiCoreV1LoadBalancerIngress.jl") -include("models/model_IoK8sApiCoreV1LoadBalancerStatus.jl") -include("models/model_IoK8sApiCoreV1LocalObjectReference.jl") -include("models/model_IoK8sApiCoreV1LocalVolumeSource.jl") -include("models/model_IoK8sApiCoreV1NFSVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Namespace.jl") -include("models/model_IoK8sApiCoreV1NamespaceCondition.jl") -include("models/model_IoK8sApiCoreV1NamespaceList.jl") -include("models/model_IoK8sApiCoreV1NamespaceSpec.jl") -include("models/model_IoK8sApiCoreV1NamespaceStatus.jl") -include("models/model_IoK8sApiCoreV1Node.jl") -include("models/model_IoK8sApiCoreV1NodeAddress.jl") -include("models/model_IoK8sApiCoreV1NodeAffinity.jl") -include("models/model_IoK8sApiCoreV1NodeCondition.jl") -include("models/model_IoK8sApiCoreV1NodeConfigSource.jl") -include("models/model_IoK8sApiCoreV1NodeConfigStatus.jl") -include("models/model_IoK8sApiCoreV1NodeDaemonEndpoints.jl") -include("models/model_IoK8sApiCoreV1NodeList.jl") -include("models/model_IoK8sApiCoreV1NodeSelector.jl") -include("models/model_IoK8sApiCoreV1NodeSelectorRequirement.jl") -include("models/model_IoK8sApiCoreV1NodeSelectorTerm.jl") -include("models/model_IoK8sApiCoreV1NodeSpec.jl") -include("models/model_IoK8sApiCoreV1NodeStatus.jl") -include("models/model_IoK8sApiCoreV1NodeSystemInfo.jl") -include("models/model_IoK8sApiCoreV1ObjectFieldSelector.jl") -include("models/model_IoK8sApiCoreV1ObjectReference.jl") -include("models/model_IoK8sApiCoreV1PersistentVolume.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaim.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaimCondition.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaimList.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaimSpec.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaimStatus.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeList.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeSpec.jl") -include("models/model_IoK8sApiCoreV1PersistentVolumeStatus.jl") -include("models/model_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Pod.jl") -include("models/model_IoK8sApiCoreV1PodAffinity.jl") -include("models/model_IoK8sApiCoreV1PodAffinityTerm.jl") -include("models/model_IoK8sApiCoreV1PodAntiAffinity.jl") -include("models/model_IoK8sApiCoreV1PodCondition.jl") -include("models/model_IoK8sApiCoreV1PodDNSConfig.jl") -include("models/model_IoK8sApiCoreV1PodDNSConfigOption.jl") -include("models/model_IoK8sApiCoreV1PodIP.jl") -include("models/model_IoK8sApiCoreV1PodList.jl") -include("models/model_IoK8sApiCoreV1PodReadinessGate.jl") -include("models/model_IoK8sApiCoreV1PodSecurityContext.jl") -include("models/model_IoK8sApiCoreV1PodSpec.jl") -include("models/model_IoK8sApiCoreV1PodStatus.jl") -include("models/model_IoK8sApiCoreV1PodTemplate.jl") -include("models/model_IoK8sApiCoreV1PodTemplateList.jl") -include("models/model_IoK8sApiCoreV1PodTemplateSpec.jl") -include("models/model_IoK8sApiCoreV1PortworxVolumeSource.jl") -include("models/model_IoK8sApiCoreV1PreferredSchedulingTerm.jl") -include("models/model_IoK8sApiCoreV1Probe.jl") -include("models/model_IoK8sApiCoreV1ProjectedVolumeSource.jl") -include("models/model_IoK8sApiCoreV1QuobyteVolumeSource.jl") -include("models/model_IoK8sApiCoreV1RBDPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1RBDVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ReplicationController.jl") -include("models/model_IoK8sApiCoreV1ReplicationControllerCondition.jl") -include("models/model_IoK8sApiCoreV1ReplicationControllerList.jl") -include("models/model_IoK8sApiCoreV1ReplicationControllerSpec.jl") -include("models/model_IoK8sApiCoreV1ReplicationControllerStatus.jl") -include("models/model_IoK8sApiCoreV1ResourceFieldSelector.jl") -include("models/model_IoK8sApiCoreV1ResourceQuota.jl") -include("models/model_IoK8sApiCoreV1ResourceQuotaList.jl") -include("models/model_IoK8sApiCoreV1ResourceQuotaSpec.jl") -include("models/model_IoK8sApiCoreV1ResourceQuotaStatus.jl") -include("models/model_IoK8sApiCoreV1ResourceRequirements.jl") -include("models/model_IoK8sApiCoreV1SELinuxOptions.jl") -include("models/model_IoK8sApiCoreV1ScaleIOPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ScaleIOVolumeSource.jl") -include("models/model_IoK8sApiCoreV1ScopeSelector.jl") -include("models/model_IoK8sApiCoreV1ScopedResourceSelectorRequirement.jl") -include("models/model_IoK8sApiCoreV1Secret.jl") -include("models/model_IoK8sApiCoreV1SecretEnvSource.jl") -include("models/model_IoK8sApiCoreV1SecretKeySelector.jl") -include("models/model_IoK8sApiCoreV1SecretList.jl") -include("models/model_IoK8sApiCoreV1SecretProjection.jl") -include("models/model_IoK8sApiCoreV1SecretReference.jl") -include("models/model_IoK8sApiCoreV1SecretVolumeSource.jl") -include("models/model_IoK8sApiCoreV1SecurityContext.jl") -include("models/model_IoK8sApiCoreV1Service.jl") -include("models/model_IoK8sApiCoreV1ServiceAccount.jl") -include("models/model_IoK8sApiCoreV1ServiceAccountList.jl") -include("models/model_IoK8sApiCoreV1ServiceAccountTokenProjection.jl") -include("models/model_IoK8sApiCoreV1ServiceList.jl") -include("models/model_IoK8sApiCoreV1ServicePort.jl") -include("models/model_IoK8sApiCoreV1ServiceSpec.jl") -include("models/model_IoK8sApiCoreV1ServiceStatus.jl") -include("models/model_IoK8sApiCoreV1SessionAffinityConfig.jl") -include("models/model_IoK8sApiCoreV1StorageOSPersistentVolumeSource.jl") -include("models/model_IoK8sApiCoreV1StorageOSVolumeSource.jl") -include("models/model_IoK8sApiCoreV1Sysctl.jl") -include("models/model_IoK8sApiCoreV1TCPSocketAction.jl") -include("models/model_IoK8sApiCoreV1Taint.jl") -include("models/model_IoK8sApiCoreV1Toleration.jl") -include("models/model_IoK8sApiCoreV1TopologySelectorLabelRequirement.jl") -include("models/model_IoK8sApiCoreV1TopologySelectorTerm.jl") -include("models/model_IoK8sApiCoreV1TopologySpreadConstraint.jl") -include("models/model_IoK8sApiCoreV1TypedLocalObjectReference.jl") -include("models/model_IoK8sApiCoreV1Volume.jl") -include("models/model_IoK8sApiCoreV1VolumeDevice.jl") -include("models/model_IoK8sApiCoreV1VolumeMount.jl") -include("models/model_IoK8sApiCoreV1VolumeNodeAffinity.jl") -include("models/model_IoK8sApiCoreV1VolumeProjection.jl") -include("models/model_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource.jl") -include("models/model_IoK8sApiCoreV1WeightedPodAffinityTerm.jl") -include("models/model_IoK8sApiCoreV1WindowsSecurityContextOptions.jl") -include("models/model_IoK8sApiCustomMetricsV1beta1MetricValue.jl") -include("models/model_IoK8sApiCustomMetricsV1beta1MetricValueList.jl") -include("models/model_IoK8sApiDiscoveryV1beta1Endpoint.jl") -include("models/model_IoK8sApiDiscoveryV1beta1EndpointConditions.jl") -include("models/model_IoK8sApiDiscoveryV1beta1EndpointPort.jl") -include("models/model_IoK8sApiDiscoveryV1beta1EndpointSlice.jl") -include("models/model_IoK8sApiDiscoveryV1beta1EndpointSliceList.jl") -include("models/model_IoK8sApiEventsV1beta1Event.jl") -include("models/model_IoK8sApiEventsV1beta1EventList.jl") -include("models/model_IoK8sApiEventsV1beta1EventSeries.jl") -include("models/model_IoK8sApiExtensionsV1beta1AllowedCSIDriver.jl") -include("models/model_IoK8sApiExtensionsV1beta1AllowedFlexVolume.jl") -include("models/model_IoK8sApiExtensionsV1beta1AllowedHostPath.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSet.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSetCondition.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSetList.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSetSpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSetStatus.jl") -include("models/model_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy.jl") -include("models/model_IoK8sApiExtensionsV1beta1Deployment.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentCondition.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentList.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentRollback.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentSpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentStatus.jl") -include("models/model_IoK8sApiExtensionsV1beta1DeploymentStrategy.jl") -include("models/model_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions.jl") -include("models/model_IoK8sApiExtensionsV1beta1HTTPIngressPath.jl") -include("models/model_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue.jl") -include("models/model_IoK8sApiExtensionsV1beta1HostPortRange.jl") -include("models/model_IoK8sApiExtensionsV1beta1IDRange.jl") -include("models/model_IoK8sApiExtensionsV1beta1IPBlock.jl") -include("models/model_IoK8sApiExtensionsV1beta1Ingress.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressBackend.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressList.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressRule.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressSpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressStatus.jl") -include("models/model_IoK8sApiExtensionsV1beta1IngressTLS.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicy.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicyList.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPeer.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPort.jl") -include("models/model_IoK8sApiExtensionsV1beta1NetworkPolicySpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicy.jl") -include("models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicyList.jl") -include("models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1ReplicaSet.jl") -include("models/model_IoK8sApiExtensionsV1beta1ReplicaSetCondition.jl") -include("models/model_IoK8sApiExtensionsV1beta1ReplicaSetList.jl") -include("models/model_IoK8sApiExtensionsV1beta1ReplicaSetSpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1ReplicaSetStatus.jl") -include("models/model_IoK8sApiExtensionsV1beta1RollbackConfig.jl") -include("models/model_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet.jl") -include("models/model_IoK8sApiExtensionsV1beta1RollingUpdateDeployment.jl") -include("models/model_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions.jl") -include("models/model_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions.jl") -include("models/model_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions.jl") -include("models/model_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions.jl") -include("models/model_IoK8sApiExtensionsV1beta1Scale.jl") -include("models/model_IoK8sApiExtensionsV1beta1ScaleSpec.jl") -include("models/model_IoK8sApiExtensionsV1beta1ScaleStatus.jl") -include("models/model_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowSchema.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaList.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1GroupSubject.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1LimitResponse.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1Subject.jl") -include("models/model_IoK8sApiFlowcontrolV1alpha1UserSubject.jl") -include("models/model_IoK8sApiMetricsV1beta1ContainerMetrics.jl") -include("models/model_IoK8sApiMetricsV1beta1NodeMetrics.jl") -include("models/model_IoK8sApiMetricsV1beta1NodeMetricsList.jl") -include("models/model_IoK8sApiMetricsV1beta1PodMetrics.jl") -include("models/model_IoK8sApiMetricsV1beta1PodMetricsList.jl") -include("models/model_IoK8sApiNetworkingV1IPBlock.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicy.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicyEgressRule.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicyIngressRule.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicyList.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicyPeer.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicyPort.jl") -include("models/model_IoK8sApiNetworkingV1NetworkPolicySpec.jl") -include("models/model_IoK8sApiNetworkingV1beta1HTTPIngressPath.jl") -include("models/model_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue.jl") -include("models/model_IoK8sApiNetworkingV1beta1Ingress.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressBackend.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressList.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressRule.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressSpec.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressStatus.jl") -include("models/model_IoK8sApiNetworkingV1beta1IngressTLS.jl") -include("models/model_IoK8sApiNodeV1alpha1Overhead.jl") -include("models/model_IoK8sApiNodeV1alpha1RuntimeClass.jl") -include("models/model_IoK8sApiNodeV1alpha1RuntimeClassList.jl") -include("models/model_IoK8sApiNodeV1alpha1RuntimeClassSpec.jl") -include("models/model_IoK8sApiNodeV1alpha1Scheduling.jl") -include("models/model_IoK8sApiNodeV1beta1Overhead.jl") -include("models/model_IoK8sApiNodeV1beta1RuntimeClass.jl") -include("models/model_IoK8sApiNodeV1beta1RuntimeClassList.jl") -include("models/model_IoK8sApiNodeV1beta1Scheduling.jl") -include("models/model_IoK8sApiPolicyV1beta1AllowedCSIDriver.jl") -include("models/model_IoK8sApiPolicyV1beta1AllowedFlexVolume.jl") -include("models/model_IoK8sApiPolicyV1beta1AllowedHostPath.jl") -include("models/model_IoK8sApiPolicyV1beta1Eviction.jl") -include("models/model_IoK8sApiPolicyV1beta1FSGroupStrategyOptions.jl") -include("models/model_IoK8sApiPolicyV1beta1HostPortRange.jl") -include("models/model_IoK8sApiPolicyV1beta1IDRange.jl") -include("models/model_IoK8sApiPolicyV1beta1PodDisruptionBudget.jl") -include("models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetList.jl") -include("models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec.jl") -include("models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus.jl") -include("models/model_IoK8sApiPolicyV1beta1PodSecurityPolicy.jl") -include("models/model_IoK8sApiPolicyV1beta1PodSecurityPolicyList.jl") -include("models/model_IoK8sApiPolicyV1beta1PodSecurityPolicySpec.jl") -include("models/model_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions.jl") -include("models/model_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions.jl") -include("models/model_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions.jl") -include("models/model_IoK8sApiPolicyV1beta1SELinuxStrategyOptions.jl") -include("models/model_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions.jl") -include("models/model_IoK8sApiRbacV1AggregationRule.jl") -include("models/model_IoK8sApiRbacV1ClusterRole.jl") -include("models/model_IoK8sApiRbacV1ClusterRoleBinding.jl") -include("models/model_IoK8sApiRbacV1ClusterRoleBindingList.jl") -include("models/model_IoK8sApiRbacV1ClusterRoleList.jl") -include("models/model_IoK8sApiRbacV1PolicyRule.jl") -include("models/model_IoK8sApiRbacV1Role.jl") -include("models/model_IoK8sApiRbacV1RoleBinding.jl") -include("models/model_IoK8sApiRbacV1RoleBindingList.jl") -include("models/model_IoK8sApiRbacV1RoleList.jl") -include("models/model_IoK8sApiRbacV1RoleRef.jl") -include("models/model_IoK8sApiRbacV1Subject.jl") -include("models/model_IoK8sApiRbacV1alpha1AggregationRule.jl") -include("models/model_IoK8sApiRbacV1alpha1ClusterRole.jl") -include("models/model_IoK8sApiRbacV1alpha1ClusterRoleBinding.jl") -include("models/model_IoK8sApiRbacV1alpha1ClusterRoleBindingList.jl") -include("models/model_IoK8sApiRbacV1alpha1ClusterRoleList.jl") -include("models/model_IoK8sApiRbacV1alpha1PolicyRule.jl") -include("models/model_IoK8sApiRbacV1alpha1Role.jl") -include("models/model_IoK8sApiRbacV1alpha1RoleBinding.jl") -include("models/model_IoK8sApiRbacV1alpha1RoleBindingList.jl") -include("models/model_IoK8sApiRbacV1alpha1RoleList.jl") -include("models/model_IoK8sApiRbacV1alpha1RoleRef.jl") -include("models/model_IoK8sApiRbacV1alpha1Subject.jl") -include("models/model_IoK8sApiRbacV1beta1AggregationRule.jl") -include("models/model_IoK8sApiRbacV1beta1ClusterRole.jl") -include("models/model_IoK8sApiRbacV1beta1ClusterRoleBinding.jl") -include("models/model_IoK8sApiRbacV1beta1ClusterRoleBindingList.jl") -include("models/model_IoK8sApiRbacV1beta1ClusterRoleList.jl") -include("models/model_IoK8sApiRbacV1beta1PolicyRule.jl") -include("models/model_IoK8sApiRbacV1beta1Role.jl") -include("models/model_IoK8sApiRbacV1beta1RoleBinding.jl") -include("models/model_IoK8sApiRbacV1beta1RoleBindingList.jl") -include("models/model_IoK8sApiRbacV1beta1RoleList.jl") -include("models/model_IoK8sApiRbacV1beta1RoleRef.jl") -include("models/model_IoK8sApiRbacV1beta1Subject.jl") -include("models/model_IoK8sApiSchedulingV1PriorityClass.jl") -include("models/model_IoK8sApiSchedulingV1PriorityClassList.jl") -include("models/model_IoK8sApiSchedulingV1alpha1PriorityClass.jl") -include("models/model_IoK8sApiSchedulingV1alpha1PriorityClassList.jl") -include("models/model_IoK8sApiSchedulingV1beta1PriorityClass.jl") -include("models/model_IoK8sApiSchedulingV1beta1PriorityClassList.jl") -include("models/model_IoK8sApiSettingsV1alpha1PodPreset.jl") -include("models/model_IoK8sApiSettingsV1alpha1PodPresetList.jl") -include("models/model_IoK8sApiSettingsV1alpha1PodPresetSpec.jl") -include("models/model_IoK8sApiStorageV1CSINode.jl") -include("models/model_IoK8sApiStorageV1CSINodeDriver.jl") -include("models/model_IoK8sApiStorageV1CSINodeList.jl") -include("models/model_IoK8sApiStorageV1CSINodeSpec.jl") -include("models/model_IoK8sApiStorageV1StorageClass.jl") -include("models/model_IoK8sApiStorageV1StorageClassList.jl") -include("models/model_IoK8sApiStorageV1VolumeAttachment.jl") -include("models/model_IoK8sApiStorageV1VolumeAttachmentList.jl") -include("models/model_IoK8sApiStorageV1VolumeAttachmentSource.jl") -include("models/model_IoK8sApiStorageV1VolumeAttachmentSpec.jl") -include("models/model_IoK8sApiStorageV1VolumeAttachmentStatus.jl") -include("models/model_IoK8sApiStorageV1VolumeError.jl") -include("models/model_IoK8sApiStorageV1VolumeNodeResources.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeAttachment.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeAttachmentList.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSource.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSpec.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeAttachmentStatus.jl") -include("models/model_IoK8sApiStorageV1alpha1VolumeError.jl") -include("models/model_IoK8sApiStorageV1beta1CSIDriver.jl") -include("models/model_IoK8sApiStorageV1beta1CSIDriverList.jl") -include("models/model_IoK8sApiStorageV1beta1CSIDriverSpec.jl") -include("models/model_IoK8sApiStorageV1beta1CSINode.jl") -include("models/model_IoK8sApiStorageV1beta1CSINodeDriver.jl") -include("models/model_IoK8sApiStorageV1beta1CSINodeList.jl") -include("models/model_IoK8sApiStorageV1beta1CSINodeSpec.jl") -include("models/model_IoK8sApiStorageV1beta1StorageClass.jl") -include("models/model_IoK8sApiStorageV1beta1StorageClassList.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeAttachment.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeAttachmentList.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeAttachmentSource.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeAttachmentSpec.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeAttachmentStatus.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeError.jl") -include("models/model_IoK8sApiStorageV1beta1VolumeNodeResources.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference.jl") -include("models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1APIGroup.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1APIGroupList.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1APIResource.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1APIResourceList.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1APIVersions.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptions.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1LabelSelector.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1ListMeta.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1ObjectMeta.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1OwnerReference.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1Preconditions.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1Status.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1StatusCause.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1StatusDetails.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1StatusV2.jl") -include("models/model_IoK8sApimachineryPkgApisMetaV1WatchEvent.jl") -include("models/model_IoK8sApimachineryPkgVersionInfo.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus.jl") -include("models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference.jl") -include("models/model_ShKarpenterV1alpha5Provisioner.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerList.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpec.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecConsolidation.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecLimits.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecProviderRef.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerStatus.jl") -include("models/model_ShKarpenterV1alpha5ProvisionerStatusConditionsInner.jl") diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhook.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhook.jl deleted file mode 100644 index 2577e762..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhook.jl +++ /dev/null @@ -1,78 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.MutatingWebhook -MutatingWebhook describes an admission webhook and the resources and operations it applies to. - - IoK8sApiAdmissionregistrationV1MutatingWebhook(; - admissionReviewVersions=nothing, - clientConfig=nothing, - failurePolicy=nothing, - matchPolicy=nothing, - name=nothing, - namespaceSelector=nothing, - objectSelector=nothing, - reinvocationPolicy=nothing, - rules=nothing, - sideEffects=nothing, - timeoutSeconds=nothing, - ) - - - admissionReviewVersions::Vector{String} : AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. - - clientConfig::IoK8sApiAdmissionregistrationV1WebhookClientConfig - - failurePolicy::String : FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. - - matchPolicy::String : matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Equivalent\" - - name::String : The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - objectSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - reinvocationPolicy::String : reinvocationPolicy indicates whether this webhook should be called multiple times as part of a single admission evaluation. Allowed values are \"Never\" and \"IfNeeded\". Never: the webhook will not be called more than once in a single admission evaluation. IfNeeded: the webhook will be called at least one additional time as part of the admission evaluation if the object being admitted is modified by other admission plugins after the initial webhook call. Webhooks that specify this option *must* be idempotent, able to process objects they previously admitted. Note: * the number of additional invocations is not guaranteed to be exactly one. * if additional invocations result in further modifications to the object, webhooks are not guaranteed to be invoked again. * webhooks that use this option may be reordered to minimize the number of additional invocations. * to validate an object after all mutations are guaranteed complete, use a validating admission webhook instead. Defaults to \"Never\". - - rules::Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations} : Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. - - sideEffects::String : SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission change and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. - - timeoutSeconds::Int64 : TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1MutatingWebhook <: OpenAPI.APIModel - admissionReviewVersions::Union{Nothing, Vector{String}} = nothing - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1WebhookClientConfig } - failurePolicy::Union{Nothing, String} = nothing - matchPolicy::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - objectSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - reinvocationPolicy::Union{Nothing, String} = nothing - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations} } - sideEffects::Union{Nothing, String} = nothing - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1MutatingWebhook(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, reinvocationPolicy, rules, sideEffects, timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("admissionReviewVersions"), admissionReviewVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("failurePolicy"), failurePolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("matchPolicy"), matchPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("objectSelector"), objectSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("reinvocationPolicy"), reinvocationPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("sideEffects"), sideEffects) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhook, Symbol("timeoutSeconds"), timeoutSeconds) - return new(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, reinvocationPolicy, rules, sideEffects, timeoutSeconds, ) - end -end # type IoK8sApiAdmissionregistrationV1MutatingWebhook - -const _property_types_IoK8sApiAdmissionregistrationV1MutatingWebhook = Dict{Symbol,String}(Symbol("admissionReviewVersions")=>"Vector{String}", Symbol("clientConfig")=>"IoK8sApiAdmissionregistrationV1WebhookClientConfig", Symbol("failurePolicy")=>"String", Symbol("matchPolicy")=>"String", Symbol("name")=>"String", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("objectSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("reinvocationPolicy")=>"String", Symbol("rules")=>"Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations}", Symbol("sideEffects")=>"String", Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhook }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1MutatingWebhook[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1MutatingWebhook) - o.admissionReviewVersions === nothing && (return false) - o.clientConfig === nothing && (return false) - o.name === nothing && (return false) - o.sideEffects === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhook }, name::Symbol, val) - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1MutatingWebhook", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration.jl deleted file mode 100644 index 01e6088b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration -MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. - - IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - webhooks=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - webhooks::Vector{IoK8sApiAdmissionregistrationV1MutatingWebhook} : Webhooks is a list of webhooks and the affected resources and operations. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - webhooks::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1MutatingWebhook} } - - function IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration(apiVersion, kind, metadata, webhooks, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration, Symbol("webhooks"), webhooks) - return new(apiVersion, kind, metadata, webhooks, ) - end -end # type IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration - -const _property_types_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("webhooks")=>"Vector{IoK8sApiAdmissionregistrationV1MutatingWebhook}", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList.jl deleted file mode 100644 index 257e1c9e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.MutatingWebhookConfigurationList -MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. - - IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration} : List of MutatingWebhookConfiguration. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList - -const _property_types_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1RuleWithOperations.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1RuleWithOperations.jl deleted file mode 100644 index d314ba5b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1RuleWithOperations.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.RuleWithOperations -RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. - - IoK8sApiAdmissionregistrationV1RuleWithOperations(; - apiGroups=nothing, - apiVersions=nothing, - operations=nothing, - resources=nothing, - scope=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. - - apiVersions::Vector{String} : APIVersions is the API versions the resources belong to. '*' is all versions. If '*' is present, the length of the slice must be one. Required. - - operations::Vector{String} : Operations is the operations the admission hook cares about - CREATE, UPDATE, or * for all operations. If '*' is present, the length of the slice must be one. Required. - - resources::Vector{String} : Resources is a list of resources this rule applies to. For example: 'pods' means pods. 'pods/log' means the log subresource of pods. '*' means all resources, but not subresources. 'pods/*' means all subresources of pods. '*/scale' means all scale subresources. '*/*' means all resources and their subresources. If wildcard is present, the validation rule will ensure resources do not overlap with each other. Depending on the enclosing object, subresources might not be allowed. Required. - - scope::String : scope specifies the scope of this rule. Valid values are \"Cluster\", \"Namespaced\", and \"*\" \"Cluster\" means that only cluster-scoped resources will match this rule. Namespace API objects are cluster-scoped. \"Namespaced\" means that only namespaced resources will match this rule. \"*\" means that there are no scope restrictions. Subresources match the scope of their parent resource. Default is \"*\". -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1RuleWithOperations <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - apiVersions::Union{Nothing, Vector{String}} = nothing - operations::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - scope::Union{Nothing, String} = nothing - - function IoK8sApiAdmissionregistrationV1RuleWithOperations(apiGroups, apiVersions, operations, resources, scope, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1RuleWithOperations, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1RuleWithOperations, Symbol("apiVersions"), apiVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1RuleWithOperations, Symbol("operations"), operations) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1RuleWithOperations, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1RuleWithOperations, Symbol("scope"), scope) - return new(apiGroups, apiVersions, operations, resources, scope, ) - end -end # type IoK8sApiAdmissionregistrationV1RuleWithOperations - -const _property_types_IoK8sApiAdmissionregistrationV1RuleWithOperations = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("apiVersions")=>"Vector{String}", Symbol("operations")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("scope")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1RuleWithOperations }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1RuleWithOperations[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1RuleWithOperations) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1RuleWithOperations }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ServiceReference.jl deleted file mode 100644 index fd79c0a9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ServiceReference.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sApiAdmissionregistrationV1ServiceReference(; - name=nothing, - namespace=nothing, - path=nothing, - port=nothing, - ) - - - name::String : `name` is the name of the service. Required - - namespace::String : `namespace` is the namespace of the service. Required - - path::String : `path` is an optional URL path which will be sent in any request to this service. - - port::Int64 : If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1ServiceReference(name, namespace, path, port, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ServiceReference, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ServiceReference, Symbol("port"), port) - return new(name, namespace, path, port, ) - end -end # type IoK8sApiAdmissionregistrationV1ServiceReference - -const _property_types_IoK8sApiAdmissionregistrationV1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("path")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1ServiceReference[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1ServiceReference) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhook.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhook.jl deleted file mode 100644 index 4801dd1f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhook.jl +++ /dev/null @@ -1,74 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.ValidatingWebhook -ValidatingWebhook describes an admission webhook and the resources and operations it applies to. - - IoK8sApiAdmissionregistrationV1ValidatingWebhook(; - admissionReviewVersions=nothing, - clientConfig=nothing, - failurePolicy=nothing, - matchPolicy=nothing, - name=nothing, - namespaceSelector=nothing, - objectSelector=nothing, - rules=nothing, - sideEffects=nothing, - timeoutSeconds=nothing, - ) - - - admissionReviewVersions::Vector{String} : AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. - - clientConfig::IoK8sApiAdmissionregistrationV1WebhookClientConfig - - failurePolicy::String : FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. - - matchPolicy::String : matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Equivalent\" - - name::String : The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - objectSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - rules::Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations} : Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. - - sideEffects::String : SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission change and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. - - timeoutSeconds::Int64 : TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1ValidatingWebhook <: OpenAPI.APIModel - admissionReviewVersions::Union{Nothing, Vector{String}} = nothing - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1WebhookClientConfig } - failurePolicy::Union{Nothing, String} = nothing - matchPolicy::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - objectSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations} } - sideEffects::Union{Nothing, String} = nothing - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1ValidatingWebhook(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, rules, sideEffects, timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("admissionReviewVersions"), admissionReviewVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("failurePolicy"), failurePolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("matchPolicy"), matchPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("objectSelector"), objectSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("sideEffects"), sideEffects) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhook, Symbol("timeoutSeconds"), timeoutSeconds) - return new(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, rules, sideEffects, timeoutSeconds, ) - end -end # type IoK8sApiAdmissionregistrationV1ValidatingWebhook - -const _property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhook = Dict{Symbol,String}(Symbol("admissionReviewVersions")=>"Vector{String}", Symbol("clientConfig")=>"IoK8sApiAdmissionregistrationV1WebhookClientConfig", Symbol("failurePolicy")=>"String", Symbol("matchPolicy")=>"String", Symbol("name")=>"String", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("objectSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("rules")=>"Vector{IoK8sApiAdmissionregistrationV1RuleWithOperations}", Symbol("sideEffects")=>"String", Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhook }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhook[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1ValidatingWebhook) - o.admissionReviewVersions === nothing && (return false) - o.clientConfig === nothing && (return false) - o.name === nothing && (return false) - o.sideEffects === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhook }, name::Symbol, val) - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1ValidatingWebhook", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration.jl deleted file mode 100644 index 98c984a7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.ValidatingWebhookConfiguration -ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. - - IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - webhooks=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - webhooks::Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhook} : Webhooks is a list of webhooks and the affected resources and operations. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - webhooks::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhook} } - - function IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration(apiVersion, kind, metadata, webhooks, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration, Symbol("webhooks"), webhooks) - return new(apiVersion, kind, metadata, webhooks, ) - end -end # type IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration - -const _property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("webhooks")=>"Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhook}", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList.jl deleted file mode 100644 index 22a46f85..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.ValidatingWebhookConfigurationList -ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. - - IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration} : List of ValidatingWebhookConfiguration. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList - -const _property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1WebhookClientConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1WebhookClientConfig.jl deleted file mode 100644 index 9957d603..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1WebhookClientConfig.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1.WebhookClientConfig -WebhookClientConfig contains the information to make a TLS connection with the webhook - - IoK8sApiAdmissionregistrationV1WebhookClientConfig(; - caBundle=nothing, - service=nothing, - url=nothing, - ) - - - caBundle::Vector{UInt8} : `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. - - service::IoK8sApiAdmissionregistrationV1ServiceReference - - url::String : `url` gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1WebhookClientConfig <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1ServiceReference } - url::Union{Nothing, String} = nothing - - function IoK8sApiAdmissionregistrationV1WebhookClientConfig(caBundle, service, url, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1WebhookClientConfig, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1WebhookClientConfig, Symbol("service"), service) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1WebhookClientConfig, Symbol("url"), url) - return new(caBundle, service, url, ) - end -end # type IoK8sApiAdmissionregistrationV1WebhookClientConfig - -const _property_types_IoK8sApiAdmissionregistrationV1WebhookClientConfig = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("service")=>"IoK8sApiAdmissionregistrationV1ServiceReference", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1WebhookClientConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1WebhookClientConfig[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1WebhookClientConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1WebhookClientConfig }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1WebhookClientConfig", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1WebhookClientConfig", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook.jl deleted file mode 100644 index ad6c5b05..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook.jl +++ /dev/null @@ -1,76 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.MutatingWebhook -MutatingWebhook describes an admission webhook and the resources and operations it applies to. - - IoK8sApiAdmissionregistrationV1beta1MutatingWebhook(; - admissionReviewVersions=nothing, - clientConfig=nothing, - failurePolicy=nothing, - matchPolicy=nothing, - name=nothing, - namespaceSelector=nothing, - objectSelector=nothing, - reinvocationPolicy=nothing, - rules=nothing, - sideEffects=nothing, - timeoutSeconds=nothing, - ) - - - admissionReviewVersions::Vector{String} : AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. - - clientConfig::IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig - - failurePolicy::String : FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Ignore. - - matchPolicy::String : matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Exact\" - - name::String : The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - objectSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - reinvocationPolicy::String : reinvocationPolicy indicates whether this webhook should be called multiple times as part of a single admission evaluation. Allowed values are \"Never\" and \"IfNeeded\". Never: the webhook will not be called more than once in a single admission evaluation. IfNeeded: the webhook will be called at least one additional time as part of the admission evaluation if the object being admitted is modified by other admission plugins after the initial webhook call. Webhooks that specify this option *must* be idempotent, able to process objects they previously admitted. Note: * the number of additional invocations is not guaranteed to be exactly one. * if additional invocations result in further modifications to the object, webhooks are not guaranteed to be invoked again. * webhooks that use this option may be reordered to minimize the number of additional invocations. * to validate an object after all mutations are guaranteed complete, use a validating admission webhook instead. Defaults to \"Never\". - - rules::Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations} : Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. - - sideEffects::String : SideEffects states whether this webhook has side effects. Acceptable values are: Unknown, None, Some, NoneOnDryRun Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission change and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. Defaults to Unknown. - - timeoutSeconds::Int64 : TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 30 seconds. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1MutatingWebhook <: OpenAPI.APIModel - admissionReviewVersions::Union{Nothing, Vector{String}} = nothing - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig } - failurePolicy::Union{Nothing, String} = nothing - matchPolicy::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - objectSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - reinvocationPolicy::Union{Nothing, String} = nothing - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations} } - sideEffects::Union{Nothing, String} = nothing - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1beta1MutatingWebhook(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, reinvocationPolicy, rules, sideEffects, timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("admissionReviewVersions"), admissionReviewVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("failurePolicy"), failurePolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("matchPolicy"), matchPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("objectSelector"), objectSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("reinvocationPolicy"), reinvocationPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("sideEffects"), sideEffects) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhook, Symbol("timeoutSeconds"), timeoutSeconds) - return new(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, reinvocationPolicy, rules, sideEffects, timeoutSeconds, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1MutatingWebhook - -const _property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook = Dict{Symbol,String}(Symbol("admissionReviewVersions")=>"Vector{String}", Symbol("clientConfig")=>"IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig", Symbol("failurePolicy")=>"String", Symbol("matchPolicy")=>"String", Symbol("name")=>"String", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("objectSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("reinvocationPolicy")=>"String", Symbol("rules")=>"Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations}", Symbol("sideEffects")=>"String", Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhook }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhook[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1MutatingWebhook) - o.clientConfig === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhook }, name::Symbol, val) - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1beta1MutatingWebhook", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration.jl deleted file mode 100644 index 57e60dc4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.MutatingWebhookConfiguration -MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 MutatingWebhookConfiguration instead. - - IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - webhooks=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - webhooks::Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhook} : Webhooks is a list of webhooks and the affected resources and operations. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - webhooks::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhook} } - - function IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration(apiVersion, kind, metadata, webhooks, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration, Symbol("webhooks"), webhooks) - return new(apiVersion, kind, metadata, webhooks, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration - -const _property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("webhooks")=>"Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhook}", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList.jl deleted file mode 100644 index d9698f74..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.MutatingWebhookConfigurationList -MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. - - IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration} : List of MutatingWebhookConfiguration. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList - -const _property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations.jl deleted file mode 100644 index 67bd6680..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.RuleWithOperations -RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. - - IoK8sApiAdmissionregistrationV1beta1RuleWithOperations(; - apiGroups=nothing, - apiVersions=nothing, - operations=nothing, - resources=nothing, - scope=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. - - apiVersions::Vector{String} : APIVersions is the API versions the resources belong to. '*' is all versions. If '*' is present, the length of the slice must be one. Required. - - operations::Vector{String} : Operations is the operations the admission hook cares about - CREATE, UPDATE, or * for all operations. If '*' is present, the length of the slice must be one. Required. - - resources::Vector{String} : Resources is a list of resources this rule applies to. For example: 'pods' means pods. 'pods/log' means the log subresource of pods. '*' means all resources, but not subresources. 'pods/*' means all subresources of pods. '*/scale' means all scale subresources. '*/*' means all resources and their subresources. If wildcard is present, the validation rule will ensure resources do not overlap with each other. Depending on the enclosing object, subresources might not be allowed. Required. - - scope::String : scope specifies the scope of this rule. Valid values are \"Cluster\", \"Namespaced\", and \"*\" \"Cluster\" means that only cluster-scoped resources will match this rule. Namespace API objects are cluster-scoped. \"Namespaced\" means that only namespaced resources will match this rule. \"*\" means that there are no scope restrictions. Subresources match the scope of their parent resource. Default is \"*\". -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1RuleWithOperations <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - apiVersions::Union{Nothing, Vector{String}} = nothing - operations::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - scope::Union{Nothing, String} = nothing - - function IoK8sApiAdmissionregistrationV1beta1RuleWithOperations(apiGroups, apiVersions, operations, resources, scope, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1RuleWithOperations, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1RuleWithOperations, Symbol("apiVersions"), apiVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1RuleWithOperations, Symbol("operations"), operations) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1RuleWithOperations, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1RuleWithOperations, Symbol("scope"), scope) - return new(apiGroups, apiVersions, operations, resources, scope, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1RuleWithOperations - -const _property_types_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("apiVersions")=>"Vector{String}", Symbol("operations")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("scope")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1RuleWithOperations }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1RuleWithOperations[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1RuleWithOperations) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1RuleWithOperations }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ServiceReference.jl deleted file mode 100644 index 43aab1b3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ServiceReference.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sApiAdmissionregistrationV1beta1ServiceReference(; - name=nothing, - namespace=nothing, - path=nothing, - port=nothing, - ) - - - name::String : `name` is the name of the service. Required - - namespace::String : `namespace` is the namespace of the service. Required - - path::String : `path` is an optional URL path which will be sent in any request to this service. - - port::Int64 : If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1beta1ServiceReference(name, namespace, path, port, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ServiceReference, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ServiceReference, Symbol("port"), port) - return new(name, namespace, path, port, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1ServiceReference - -const _property_types_IoK8sApiAdmissionregistrationV1beta1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("path")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1ServiceReference[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1ServiceReference) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1beta1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook.jl deleted file mode 100644 index bed203ec..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook.jl +++ /dev/null @@ -1,72 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.ValidatingWebhook -ValidatingWebhook describes an admission webhook and the resources and operations it applies to. - - IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook(; - admissionReviewVersions=nothing, - clientConfig=nothing, - failurePolicy=nothing, - matchPolicy=nothing, - name=nothing, - namespaceSelector=nothing, - objectSelector=nothing, - rules=nothing, - sideEffects=nothing, - timeoutSeconds=nothing, - ) - - - admissionReviewVersions::Vector{String} : AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. Default to `['v1beta1']`. - - clientConfig::IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig - - failurePolicy::String : FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Ignore. - - matchPolicy::String : matchPolicy defines how the \"rules\" list is used to match incoming requests. Allowed values are \"Exact\" or \"Equivalent\". - Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. - Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and \"rules\" only included `apiGroups:[\"apps\"], apiVersions:[\"v1\"], resources: [\"deployments\"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. Defaults to \"Exact\" - - name::String : The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - objectSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - rules::Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations} : Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. - - sideEffects::String : SideEffects states whether this webhook has side effects. Acceptable values are: Unknown, None, Some, NoneOnDryRun Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission change and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. Defaults to Unknown. - - timeoutSeconds::Int64 : TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 30 seconds. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook <: OpenAPI.APIModel - admissionReviewVersions::Union{Nothing, Vector{String}} = nothing - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig } - failurePolicy::Union{Nothing, String} = nothing - matchPolicy::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - objectSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations} } - sideEffects::Union{Nothing, String} = nothing - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, rules, sideEffects, timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("admissionReviewVersions"), admissionReviewVersions) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("failurePolicy"), failurePolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("matchPolicy"), matchPolicy) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("objectSelector"), objectSelector) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("sideEffects"), sideEffects) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook, Symbol("timeoutSeconds"), timeoutSeconds) - return new(admissionReviewVersions, clientConfig, failurePolicy, matchPolicy, name, namespaceSelector, objectSelector, rules, sideEffects, timeoutSeconds, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook - -const _property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook = Dict{Symbol,String}(Symbol("admissionReviewVersions")=>"Vector{String}", Symbol("clientConfig")=>"IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig", Symbol("failurePolicy")=>"String", Symbol("matchPolicy")=>"String", Symbol("name")=>"String", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("objectSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("rules")=>"Vector{IoK8sApiAdmissionregistrationV1beta1RuleWithOperations}", Symbol("sideEffects")=>"String", Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook) - o.clientConfig === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook }, name::Symbol, val) - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration.jl deleted file mode 100644 index 0295f018..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration -ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. Deprecated in v1.16, planned for removal in v1.19. Use admissionregistration.k8s.io/v1 ValidatingWebhookConfiguration instead. - - IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - webhooks=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - webhooks::Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook} : Webhooks is a list of webhooks and the affected resources and operations. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - webhooks::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook} } - - function IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration(apiVersion, kind, metadata, webhooks, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration, Symbol("webhooks"), webhooks) - return new(apiVersion, kind, metadata, webhooks, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration - -const _property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("webhooks")=>"Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook}", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList.jl deleted file mode 100644 index 990f44da..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.ValidatingWebhookConfigurationList -ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. - - IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration} : List of ValidatingWebhookConfiguration. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList - -const _property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig.jl deleted file mode 100644 index 218bc66e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.admissionregistration.v1beta1.WebhookClientConfig -WebhookClientConfig contains the information to make a TLS connection with the webhook - - IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig(; - caBundle=nothing, - service=nothing, - url=nothing, - ) - - - caBundle::Vector{UInt8} : `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. - - service::IoK8sApiAdmissionregistrationV1beta1ServiceReference - - url::String : `url` gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. -""" -Base.@kwdef mutable struct IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sApiAdmissionregistrationV1beta1ServiceReference } - url::Union{Nothing, String} = nothing - - function IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig(caBundle, service, url, ) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig, Symbol("service"), service) - OpenAPI.validate_property(IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig, Symbol("url"), url) - return new(caBundle, service, url, ) - end -end # type IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig - -const _property_types_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("service")=>"IoK8sApiAdmissionregistrationV1beta1ServiceReference", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig[name]))} - -function check_required(o::IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevision.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevision.jl deleted file mode 100644 index 01d8b058..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevision.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ControllerRevision -ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. - - IoK8sApiAppsV1ControllerRevision(; - apiVersion=nothing, - data=nothing, - kind=nothing, - metadata=nothing, - revision=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - data::Any : RawExtension is used to hold extensions in external versions. To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. // Internal package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.Object `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // External package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.RawExtension `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // On the wire, the JSON will look something like this: { \"kind\":\"MyAPIObject\", \"apiVersion\":\"v1\", \"myPlugin\": { \"kind\":\"PluginA\", \"aOption\":\"foo\", }, } So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - revision::Int64 : Revision indicates the revision of the state represented by Data. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ControllerRevision <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - data::Union{Nothing, Any} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - revision::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1ControllerRevision(apiVersion, data, kind, metadata, revision, ) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevision, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevision, Symbol("data"), data) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevision, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevision, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevision, Symbol("revision"), revision) - return new(apiVersion, data, kind, metadata, revision, ) - end -end # type IoK8sApiAppsV1ControllerRevision - -const _property_types_IoK8sApiAppsV1ControllerRevision = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("data")=>"Any", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("revision")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ControllerRevision }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ControllerRevision[name]))} - -function check_required(o::IoK8sApiAppsV1ControllerRevision) - o.revision === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ControllerRevision }, name::Symbol, val) - if name === Symbol("revision") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ControllerRevision", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevisionList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevisionList.jl deleted file mode 100644 index 87c7536a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ControllerRevisionList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ControllerRevisionList -ControllerRevisionList is a resource containing a list of ControllerRevision objects. - - IoK8sApiAppsV1ControllerRevisionList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1ControllerRevision} : Items is the list of ControllerRevisions - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ControllerRevisionList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1ControllerRevision} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1ControllerRevisionList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevisionList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevisionList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevisionList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1ControllerRevisionList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1ControllerRevisionList - -const _property_types_IoK8sApiAppsV1ControllerRevisionList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1ControllerRevision}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ControllerRevisionList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ControllerRevisionList[name]))} - -function check_required(o::IoK8sApiAppsV1ControllerRevisionList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ControllerRevisionList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSet.jl deleted file mode 100644 index 523f8f20..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSet -DaemonSet represents the configuration of a daemon set. - - IoK8sApiAppsV1DaemonSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1DaemonSetSpec - - status::IoK8sApiAppsV1DaemonSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DaemonSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DaemonSetStatus } - - function IoK8sApiAppsV1DaemonSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1DaemonSet - -const _property_types_IoK8sApiAppsV1DaemonSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1DaemonSetSpec", Symbol("status")=>"IoK8sApiAppsV1DaemonSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSet[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetCondition.jl deleted file mode 100644 index 49c11397..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSetCondition -DaemonSetCondition describes the state of a DaemonSet at a certain point. - - IoK8sApiAppsV1DaemonSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of DaemonSet condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1DaemonSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1DaemonSetCondition - -const _property_types_IoK8sApiAppsV1DaemonSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetList.jl deleted file mode 100644 index 1a751505..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSetList -DaemonSetList is a collection of daemon sets. - - IoK8sApiAppsV1DaemonSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1DaemonSet} : A list of daemon sets. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1DaemonSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1DaemonSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1DaemonSetList - -const _property_types_IoK8sApiAppsV1DaemonSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1DaemonSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSetList[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetSpec.jl deleted file mode 100644 index a3b0b96c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetSpec.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSetSpec -DaemonSetSpec is the specification of a daemon set. - - IoK8sApiAppsV1DaemonSetSpec(; - minReadySeconds=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - template=nothing, - updateStrategy=nothing, - ) - - - minReadySeconds::Int64 : The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). - - revisionHistoryLimit::Int64 : The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec - - updateStrategy::IoK8sApiAppsV1DaemonSetUpdateStrategy -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DaemonSetUpdateStrategy } - - function IoK8sApiAppsV1DaemonSetSpec(minReadySeconds, revisionHistoryLimit, selector, template, updateStrategy, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetSpec, Symbol("updateStrategy"), updateStrategy) - return new(minReadySeconds, revisionHistoryLimit, selector, template, updateStrategy, ) - end -end # type IoK8sApiAppsV1DaemonSetSpec - -const _property_types_IoK8sApiAppsV1DaemonSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("updateStrategy")=>"IoK8sApiAppsV1DaemonSetUpdateStrategy", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSetSpec) - o.selector === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetStatus.jl deleted file mode 100644 index 0a6fe883..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetStatus.jl +++ /dev/null @@ -1,98 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSetStatus -DaemonSetStatus represents the current status of a daemon set. - - IoK8sApiAppsV1DaemonSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentNumberScheduled=nothing, - desiredNumberScheduled=nothing, - numberAvailable=nothing, - numberMisscheduled=nothing, - numberReady=nothing, - numberUnavailable=nothing, - observedGeneration=nothing, - updatedNumberScheduled=nothing, - ) - - - collisionCount::Int64 : Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiAppsV1DaemonSetCondition} : Represents the latest available observations of a DaemonSet's current state. - - currentNumberScheduled::Int64 : The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - desiredNumberScheduled::Int64 : The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberAvailable::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) - - numberMisscheduled::Int64 : The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberReady::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. - - numberUnavailable::Int64 : The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) - - observedGeneration::Int64 : The most recent generation observed by the daemon set controller. - - updatedNumberScheduled::Int64 : The total number of nodes that are running updated daemon pod -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1DaemonSetCondition} } - currentNumberScheduled::Union{Nothing, Int64} = nothing - desiredNumberScheduled::Union{Nothing, Int64} = nothing - numberAvailable::Union{Nothing, Int64} = nothing - numberMisscheduled::Union{Nothing, Int64} = nothing - numberReady::Union{Nothing, Int64} = nothing - numberUnavailable::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - updatedNumberScheduled::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1DaemonSetStatus(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("currentNumberScheduled"), currentNumberScheduled) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("desiredNumberScheduled"), desiredNumberScheduled) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("numberAvailable"), numberAvailable) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("numberMisscheduled"), numberMisscheduled) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("numberReady"), numberReady) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("numberUnavailable"), numberUnavailable) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetStatus, Symbol("updatedNumberScheduled"), updatedNumberScheduled) - return new(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - end -end # type IoK8sApiAppsV1DaemonSetStatus - -const _property_types_IoK8sApiAppsV1DaemonSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1DaemonSetCondition}", Symbol("currentNumberScheduled")=>"Int64", Symbol("desiredNumberScheduled")=>"Int64", Symbol("numberAvailable")=>"Int64", Symbol("numberMisscheduled")=>"Int64", Symbol("numberReady")=>"Int64", Symbol("numberUnavailable")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("updatedNumberScheduled")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSetStatus) - o.currentNumberScheduled === nothing && (return false) - o.desiredNumberScheduled === nothing && (return false) - o.numberMisscheduled === nothing && (return false) - o.numberReady === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("currentNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("desiredNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberAvailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberMisscheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberReady") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int64") - end - if name === Symbol("updatedNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DaemonSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetUpdateStrategy.jl deleted file mode 100644 index 45bf4f9b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DaemonSetUpdateStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DaemonSetUpdateStrategy -DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. - - IoK8sApiAppsV1DaemonSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1RollingUpdateDaemonSet - - type::String : Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DaemonSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1RollingUpdateDaemonSet } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1DaemonSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1DaemonSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1DaemonSetUpdateStrategy - -const _property_types_IoK8sApiAppsV1DaemonSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1RollingUpdateDaemonSet", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DaemonSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DaemonSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1DaemonSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DaemonSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1Deployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1Deployment.jl deleted file mode 100644 index de4cc11c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1Deployment.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.Deployment -Deployment enables declarative updates for Pods and ReplicaSets. - - IoK8sApiAppsV1Deployment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1DeploymentSpec - - status::IoK8sApiAppsV1DeploymentStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1Deployment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DeploymentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DeploymentStatus } - - function IoK8sApiAppsV1Deployment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1Deployment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1Deployment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1Deployment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1Deployment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1Deployment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1Deployment - -const _property_types_IoK8sApiAppsV1Deployment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1DeploymentSpec", Symbol("status")=>"IoK8sApiAppsV1DeploymentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1Deployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1Deployment[name]))} - -function check_required(o::IoK8sApiAppsV1Deployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1Deployment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentCondition.jl deleted file mode 100644 index 255c7f84..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DeploymentCondition -DeploymentCondition describes the state of a deployment at a certain point. - - IoK8sApiAppsV1DeploymentCondition(; - lastTransitionTime=nothing, - lastUpdateTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastUpdateTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of deployment condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DeploymentCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - lastUpdateTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1DeploymentCondition(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("lastUpdateTime"), lastUpdateTime) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentCondition, Symbol("type"), type) - return new(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1DeploymentCondition - -const _property_types_IoK8sApiAppsV1DeploymentCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("lastUpdateTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DeploymentCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DeploymentCondition[name]))} - -function check_required(o::IoK8sApiAppsV1DeploymentCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DeploymentCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentCondition", :format, val, "date-time") - end - if name === Symbol("lastUpdateTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentList.jl deleted file mode 100644 index 670c62f8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DeploymentList -DeploymentList is a list of Deployments. - - IoK8sApiAppsV1DeploymentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1Deployment} : Items is the list of Deployments. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DeploymentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1Deployment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1DeploymentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1DeploymentList - -const _property_types_IoK8sApiAppsV1DeploymentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1Deployment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DeploymentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DeploymentList[name]))} - -function check_required(o::IoK8sApiAppsV1DeploymentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DeploymentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentSpec.jl deleted file mode 100644 index 940c0d5b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentSpec.jl +++ /dev/null @@ -1,73 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DeploymentSpec -DeploymentSpec is the specification of the desired behavior of the Deployment. - - IoK8sApiAppsV1DeploymentSpec(; - minReadySeconds=nothing, - paused=nothing, - progressDeadlineSeconds=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - strategy=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - paused::Bool : Indicates that the deployment is paused. - - progressDeadlineSeconds::Int64 : The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. - - replicas::Int64 : Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. - - revisionHistoryLimit::Int64 : The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - strategy::IoK8sApiAppsV1DeploymentStrategy - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DeploymentSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - paused::Union{Nothing, Bool} = nothing - progressDeadlineSeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - strategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1DeploymentStrategy } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiAppsV1DeploymentSpec(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, selector, strategy, template, ) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("paused"), paused) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("progressDeadlineSeconds"), progressDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentSpec, Symbol("template"), template) - return new(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, selector, strategy, template, ) - end -end # type IoK8sApiAppsV1DeploymentSpec - -const _property_types_IoK8sApiAppsV1DeploymentSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("paused")=>"Bool", Symbol("progressDeadlineSeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("strategy")=>"IoK8sApiAppsV1DeploymentStrategy", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DeploymentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DeploymentSpec[name]))} - -function check_required(o::IoK8sApiAppsV1DeploymentSpec) - o.selector === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DeploymentSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("progressDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStatus.jl deleted file mode 100644 index 511d7cca..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStatus.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DeploymentStatus -DeploymentStatus is the most recently observed status of the Deployment. - - IoK8sApiAppsV1DeploymentStatus(; - availableReplicas=nothing, - collisionCount=nothing, - conditions=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - unavailableReplicas=nothing, - updatedReplicas=nothing, - ) - - - availableReplicas::Int64 : Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. - - collisionCount::Int64 : Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. - - conditions::Vector{IoK8sApiAppsV1DeploymentCondition} : Represents the latest available observations of a deployment's current state. - - observedGeneration::Int64 : The generation observed by the deployment controller. - - readyReplicas::Int64 : Total number of ready pods targeted by this deployment. - - replicas::Int64 : Total number of non-terminated pods targeted by this deployment (their labels match the selector). - - unavailableReplicas::Int64 : Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. - - updatedReplicas::Int64 : Total number of non-terminated pods targeted by this deployment that have the desired template spec. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DeploymentStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1DeploymentCondition} } - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - unavailableReplicas::Union{Nothing, Int64} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1DeploymentStatus(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("unavailableReplicas"), unavailableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - end -end # type IoK8sApiAppsV1DeploymentStatus - -const _property_types_IoK8sApiAppsV1DeploymentStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1DeploymentCondition}", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("unavailableReplicas")=>"Int64", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DeploymentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DeploymentStatus[name]))} - -function check_required(o::IoK8sApiAppsV1DeploymentStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DeploymentStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("unavailableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1DeploymentStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStrategy.jl deleted file mode 100644 index 1a2b215c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1DeploymentStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.DeploymentStrategy -DeploymentStrategy describes how to replace existing pods with new ones. - - IoK8sApiAppsV1DeploymentStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1RollingUpdateDeployment - - type::String : Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1DeploymentStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1RollingUpdateDeployment } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1DeploymentStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1DeploymentStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1DeploymentStrategy - -const _property_types_IoK8sApiAppsV1DeploymentStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1RollingUpdateDeployment", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1DeploymentStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1DeploymentStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1DeploymentStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1DeploymentStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSet.jl deleted file mode 100644 index f2809c74..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ReplicaSet -ReplicaSet ensures that a specified number of pod replicas are running at any given time. - - IoK8sApiAppsV1ReplicaSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1ReplicaSetSpec - - status::IoK8sApiAppsV1ReplicaSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ReplicaSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1ReplicaSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1ReplicaSetStatus } - - function IoK8sApiAppsV1ReplicaSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1ReplicaSet - -const _property_types_IoK8sApiAppsV1ReplicaSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1ReplicaSetSpec", Symbol("status")=>"IoK8sApiAppsV1ReplicaSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ReplicaSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ReplicaSet[name]))} - -function check_required(o::IoK8sApiAppsV1ReplicaSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ReplicaSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetCondition.jl deleted file mode 100644 index 74e00b32..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ReplicaSetCondition -ReplicaSetCondition describes the state of a replica set at a certain point. - - IoK8sApiAppsV1ReplicaSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of replica set condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ReplicaSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1ReplicaSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1ReplicaSetCondition - -const _property_types_IoK8sApiAppsV1ReplicaSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ReplicaSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ReplicaSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1ReplicaSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ReplicaSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetList.jl deleted file mode 100644 index a493f201..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ReplicaSetList -ReplicaSetList is a collection of ReplicaSets. - - IoK8sApiAppsV1ReplicaSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1ReplicaSet} : List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ReplicaSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1ReplicaSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1ReplicaSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1ReplicaSetList - -const _property_types_IoK8sApiAppsV1ReplicaSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1ReplicaSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ReplicaSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ReplicaSetList[name]))} - -function check_required(o::IoK8sApiAppsV1ReplicaSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ReplicaSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetSpec.jl deleted file mode 100644 index 1fec428b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetSpec.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ReplicaSetSpec -ReplicaSetSpec is the specification of a ReplicaSet. - - IoK8sApiAppsV1ReplicaSetSpec(; - minReadySeconds=nothing, - replicas=nothing, - selector=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - replicas::Int64 : Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ReplicaSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiAppsV1ReplicaSetSpec(minReadySeconds, replicas, selector, template, ) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetSpec, Symbol("template"), template) - return new(minReadySeconds, replicas, selector, template, ) - end -end # type IoK8sApiAppsV1ReplicaSetSpec - -const _property_types_IoK8sApiAppsV1ReplicaSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ReplicaSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ReplicaSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1ReplicaSetSpec) - o.selector === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ReplicaSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetStatus.jl deleted file mode 100644 index f1db703b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1ReplicaSetStatus.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.ReplicaSetStatus -ReplicaSetStatus represents the current status of a ReplicaSet. - - IoK8sApiAppsV1ReplicaSetStatus(; - availableReplicas=nothing, - conditions=nothing, - fullyLabeledReplicas=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - ) - - - availableReplicas::Int64 : The number of available replicas (ready for at least minReadySeconds) for this replica set. - - conditions::Vector{IoK8sApiAppsV1ReplicaSetCondition} : Represents the latest available observations of a replica set's current state. - - fullyLabeledReplicas::Int64 : The number of pods that have labels matching the labels of the pod template of the replicaset. - - observedGeneration::Int64 : ObservedGeneration reflects the generation of the most recently observed ReplicaSet. - - readyReplicas::Int64 : The number of ready replicas for this replica set. - - replicas::Int64 : Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller -""" -Base.@kwdef mutable struct IoK8sApiAppsV1ReplicaSetStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1ReplicaSetCondition} } - fullyLabeledReplicas::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1ReplicaSetStatus(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("fullyLabeledReplicas"), fullyLabeledReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1ReplicaSetStatus, Symbol("replicas"), replicas) - return new(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - end -end # type IoK8sApiAppsV1ReplicaSetStatus - -const _property_types_IoK8sApiAppsV1ReplicaSetStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1ReplicaSetCondition}", Symbol("fullyLabeledReplicas")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1ReplicaSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1ReplicaSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1ReplicaSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1ReplicaSetStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("fullyLabeledReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1ReplicaSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDaemonSet.jl deleted file mode 100644 index 766a3747..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDaemonSet.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.RollingUpdateDaemonSet -Spec to control the desired behavior of daemon set rolling update. - - IoK8sApiAppsV1RollingUpdateDaemonSet(; - maxUnavailable=nothing, - ) - - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1RollingUpdateDaemonSet <: OpenAPI.APIModel - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiAppsV1RollingUpdateDaemonSet(maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiAppsV1RollingUpdateDaemonSet, Symbol("maxUnavailable"), maxUnavailable) - return new(maxUnavailable, ) - end -end # type IoK8sApiAppsV1RollingUpdateDaemonSet - -const _property_types_IoK8sApiAppsV1RollingUpdateDaemonSet = Dict{Symbol,String}(Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1RollingUpdateDaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1RollingUpdateDaemonSet[name]))} - -function check_required(o::IoK8sApiAppsV1RollingUpdateDaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1RollingUpdateDaemonSet }, name::Symbol, val) - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1RollingUpdateDaemonSet", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDeployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDeployment.jl deleted file mode 100644 index da8da453..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateDeployment.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.RollingUpdateDeployment -Spec to control the desired behavior of rolling update. - - IoK8sApiAppsV1RollingUpdateDeployment(; - maxSurge=nothing, - maxUnavailable=nothing, - ) - - - maxSurge::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1RollingUpdateDeployment <: OpenAPI.APIModel - maxSurge::Union{Nothing, Any} = nothing - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiAppsV1RollingUpdateDeployment(maxSurge, maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiAppsV1RollingUpdateDeployment, Symbol("maxSurge"), maxSurge) - OpenAPI.validate_property(IoK8sApiAppsV1RollingUpdateDeployment, Symbol("maxUnavailable"), maxUnavailable) - return new(maxSurge, maxUnavailable, ) - end -end # type IoK8sApiAppsV1RollingUpdateDeployment - -const _property_types_IoK8sApiAppsV1RollingUpdateDeployment = Dict{Symbol,String}(Symbol("maxSurge")=>"Any", Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1RollingUpdateDeployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1RollingUpdateDeployment[name]))} - -function check_required(o::IoK8sApiAppsV1RollingUpdateDeployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1RollingUpdateDeployment }, name::Symbol, val) - if name === Symbol("maxSurge") - OpenAPI.validate_param(name, "IoK8sApiAppsV1RollingUpdateDeployment", :format, val, "int-or-string") - end - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1RollingUpdateDeployment", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy.jl deleted file mode 100644 index 8a61c6a6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy -RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. - - IoK8sApiAppsV1RollingUpdateStatefulSetStrategy(; - partition=nothing, - ) - - - partition::Int64 : Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1RollingUpdateStatefulSetStrategy <: OpenAPI.APIModel - partition::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1RollingUpdateStatefulSetStrategy(partition, ) - OpenAPI.validate_property(IoK8sApiAppsV1RollingUpdateStatefulSetStrategy, Symbol("partition"), partition) - return new(partition, ) - end -end # type IoK8sApiAppsV1RollingUpdateStatefulSetStrategy - -const _property_types_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy = Dict{Symbol,String}(Symbol("partition")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1RollingUpdateStatefulSetStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1RollingUpdateStatefulSetStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1RollingUpdateStatefulSetStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1RollingUpdateStatefulSetStrategy }, name::Symbol, val) - if name === Symbol("partition") - OpenAPI.validate_param(name, "IoK8sApiAppsV1RollingUpdateStatefulSetStrategy", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSet.jl deleted file mode 100644 index f327e694..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSet -StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. - - IoK8sApiAppsV1StatefulSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1StatefulSetSpec - - status::IoK8sApiAppsV1StatefulSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1StatefulSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1StatefulSetStatus } - - function IoK8sApiAppsV1StatefulSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1StatefulSet - -const _property_types_IoK8sApiAppsV1StatefulSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1StatefulSetSpec", Symbol("status")=>"IoK8sApiAppsV1StatefulSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSet[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetCondition.jl deleted file mode 100644 index 4dd675e1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSetCondition -StatefulSetCondition describes the state of a statefulset at a certain point. - - IoK8sApiAppsV1StatefulSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of statefulset condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1StatefulSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1StatefulSetCondition - -const _property_types_IoK8sApiAppsV1StatefulSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetList.jl deleted file mode 100644 index 7762e70e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSetList -StatefulSetList is a collection of StatefulSets. - - IoK8sApiAppsV1StatefulSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1StatefulSet} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1StatefulSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1StatefulSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1StatefulSetList - -const _property_types_IoK8sApiAppsV1StatefulSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1StatefulSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSetList[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetSpec.jl deleted file mode 100644 index 4a1b87b5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetSpec.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSetSpec -A StatefulSetSpec is the specification of a StatefulSet. - - IoK8sApiAppsV1StatefulSetSpec(; - podManagementPolicy=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - serviceName=nothing, - template=nothing, - updateStrategy=nothing, - volumeClaimTemplates=nothing, - ) - - - podManagementPolicy::String : podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. - - replicas::Int64 : replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. - - revisionHistoryLimit::Int64 : revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - serviceName::String : serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. - - template::IoK8sApiCoreV1PodTemplateSpec - - updateStrategy::IoK8sApiAppsV1StatefulSetUpdateStrategy - - volumeClaimTemplates::Vector{IoK8sApiCoreV1PersistentVolumeClaim} : volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSetSpec <: OpenAPI.APIModel - podManagementPolicy::Union{Nothing, String} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - serviceName::Union{Nothing, String} = nothing - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1StatefulSetUpdateStrategy } - volumeClaimTemplates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolumeClaim} } - - function IoK8sApiAppsV1StatefulSetSpec(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("podManagementPolicy"), podManagementPolicy) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("serviceName"), serviceName) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("updateStrategy"), updateStrategy) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetSpec, Symbol("volumeClaimTemplates"), volumeClaimTemplates) - return new(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - end -end # type IoK8sApiAppsV1StatefulSetSpec - -const _property_types_IoK8sApiAppsV1StatefulSetSpec = Dict{Symbol,String}(Symbol("podManagementPolicy")=>"String", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("serviceName")=>"String", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("updateStrategy")=>"IoK8sApiAppsV1StatefulSetUpdateStrategy", Symbol("volumeClaimTemplates")=>"Vector{IoK8sApiCoreV1PersistentVolumeClaim}", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSetSpec) - o.selector === nothing && (return false) - o.serviceName === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSetSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetStatus.jl deleted file mode 100644 index 4b6f18a6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetStatus.jl +++ /dev/null @@ -1,82 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSetStatus -StatefulSetStatus represents the current state of a StatefulSet. - - IoK8sApiAppsV1StatefulSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentReplicas=nothing, - currentRevision=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - updateRevision=nothing, - updatedReplicas=nothing, - ) - - - collisionCount::Int64 : collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiAppsV1StatefulSetCondition} : Represents the latest available observations of a statefulset's current state. - - currentReplicas::Int64 : currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. - - currentRevision::String : currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). - - observedGeneration::Int64 : observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server. - - readyReplicas::Int64 : readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. - - replicas::Int64 : replicas is the number of Pods created by the StatefulSet controller. - - updateRevision::String : updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) - - updatedReplicas::Int64 : updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1StatefulSetCondition} } - currentReplicas::Union{Nothing, Int64} = nothing - currentRevision::Union{Nothing, String} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - updateRevision::Union{Nothing, String} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1StatefulSetStatus(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("currentRevision"), currentRevision) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("updateRevision"), updateRevision) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - end -end # type IoK8sApiAppsV1StatefulSetStatus - -const _property_types_IoK8sApiAppsV1StatefulSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1StatefulSetCondition}", Symbol("currentReplicas")=>"Int64", Symbol("currentRevision")=>"String", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("updateRevision")=>"String", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1StatefulSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetUpdateStrategy.jl deleted file mode 100644 index e2148fae..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1StatefulSetUpdateStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1.StatefulSetUpdateStrategy -StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. - - IoK8sApiAppsV1StatefulSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1RollingUpdateStatefulSetStrategy - - type::String : Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1StatefulSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1RollingUpdateStatefulSetStrategy } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1StatefulSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1StatefulSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1StatefulSetUpdateStrategy - -const _property_types_IoK8sApiAppsV1StatefulSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1RollingUpdateStatefulSetStrategy", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1StatefulSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1StatefulSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1StatefulSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1StatefulSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevision.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevision.jl deleted file mode 100644 index 88e47b71..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevision.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.ControllerRevision -DEPRECATED - This group version of ControllerRevision is deprecated by apps/v1beta2/ControllerRevision. See the release notes for more information. ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. - - IoK8sApiAppsV1beta1ControllerRevision(; - apiVersion=nothing, - data=nothing, - kind=nothing, - metadata=nothing, - revision=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - data::Any : RawExtension is used to hold extensions in external versions. To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. // Internal package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.Object `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // External package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.RawExtension `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // On the wire, the JSON will look something like this: { \"kind\":\"MyAPIObject\", \"apiVersion\":\"v1\", \"myPlugin\": { \"kind\":\"PluginA\", \"aOption\":\"foo\", }, } So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - revision::Int64 : Revision indicates the revision of the state represented by Data. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1ControllerRevision <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - data::Union{Nothing, Any} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - revision::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1ControllerRevision(apiVersion, data, kind, metadata, revision, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevision, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevision, Symbol("data"), data) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevision, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevision, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevision, Symbol("revision"), revision) - return new(apiVersion, data, kind, metadata, revision, ) - end -end # type IoK8sApiAppsV1beta1ControllerRevision - -const _property_types_IoK8sApiAppsV1beta1ControllerRevision = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("data")=>"Any", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("revision")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1ControllerRevision }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1ControllerRevision[name]))} - -function check_required(o::IoK8sApiAppsV1beta1ControllerRevision) - o.revision === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1ControllerRevision }, name::Symbol, val) - if name === Symbol("revision") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1ControllerRevision", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevisionList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevisionList.jl deleted file mode 100644 index ebc7bb76..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ControllerRevisionList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.ControllerRevisionList -ControllerRevisionList is a resource containing a list of ControllerRevision objects. - - IoK8sApiAppsV1beta1ControllerRevisionList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta1ControllerRevision} : Items is the list of ControllerRevisions - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1ControllerRevisionList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta1ControllerRevision} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta1ControllerRevisionList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevisionList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevisionList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevisionList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ControllerRevisionList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta1ControllerRevisionList - -const _property_types_IoK8sApiAppsV1beta1ControllerRevisionList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta1ControllerRevision}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1ControllerRevisionList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1ControllerRevisionList[name]))} - -function check_required(o::IoK8sApiAppsV1beta1ControllerRevisionList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1ControllerRevisionList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Deployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Deployment.jl deleted file mode 100644 index 2b49e073..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Deployment.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.Deployment -DEPRECATED - This group version of Deployment is deprecated by apps/v1beta2/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. - - IoK8sApiAppsV1beta1Deployment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta1DeploymentSpec - - status::IoK8sApiAppsV1beta1DeploymentStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1Deployment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1DeploymentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1DeploymentStatus } - - function IoK8sApiAppsV1beta1Deployment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Deployment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Deployment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Deployment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Deployment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Deployment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta1Deployment - -const _property_types_IoK8sApiAppsV1beta1Deployment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta1DeploymentSpec", Symbol("status")=>"IoK8sApiAppsV1beta1DeploymentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1Deployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1Deployment[name]))} - -function check_required(o::IoK8sApiAppsV1beta1Deployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1Deployment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentCondition.jl deleted file mode 100644 index bc415e5d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentCondition -DeploymentCondition describes the state of a deployment at a certain point. - - IoK8sApiAppsV1beta1DeploymentCondition(; - lastTransitionTime=nothing, - lastUpdateTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastUpdateTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of deployment condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - lastUpdateTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta1DeploymentCondition(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("lastUpdateTime"), lastUpdateTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentCondition, Symbol("type"), type) - return new(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta1DeploymentCondition - -const _property_types_IoK8sApiAppsV1beta1DeploymentCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("lastUpdateTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentCondition", :format, val, "date-time") - end - if name === Symbol("lastUpdateTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentList.jl deleted file mode 100644 index 32177fd2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentList -DeploymentList is a list of Deployments. - - IoK8sApiAppsV1beta1DeploymentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta1Deployment} : Items is the list of Deployments. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta1Deployment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta1DeploymentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta1DeploymentList - -const _property_types_IoK8sApiAppsV1beta1DeploymentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta1Deployment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentList[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentRollback.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentRollback.jl deleted file mode 100644 index 71fd5fcb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentRollback.jl +++ /dev/null @@ -1,49 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentRollback -DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. - - IoK8sApiAppsV1beta1DeploymentRollback(; - apiVersion=nothing, - kind=nothing, - name=nothing, - rollbackTo=nothing, - updatedAnnotations=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : Required: This must match the Name of a deployment. - - rollbackTo::IoK8sApiAppsV1beta1RollbackConfig - - updatedAnnotations::Dict{String, String} : The annotations to be updated to a deployment -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentRollback <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - rollbackTo = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1RollbackConfig } - updatedAnnotations::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiAppsV1beta1DeploymentRollback(apiVersion, kind, name, rollbackTo, updatedAnnotations, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentRollback, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentRollback, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentRollback, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentRollback, Symbol("rollbackTo"), rollbackTo) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentRollback, Symbol("updatedAnnotations"), updatedAnnotations) - return new(apiVersion, kind, name, rollbackTo, updatedAnnotations, ) - end -end # type IoK8sApiAppsV1beta1DeploymentRollback - -const _property_types_IoK8sApiAppsV1beta1DeploymentRollback = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("rollbackTo")=>"IoK8sApiAppsV1beta1RollbackConfig", Symbol("updatedAnnotations")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentRollback }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentRollback[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentRollback) - o.name === nothing && (return false) - o.rollbackTo === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentRollback }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentSpec.jl deleted file mode 100644 index fa7c2569..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentSpec.jl +++ /dev/null @@ -1,76 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentSpec -DeploymentSpec is the specification of the desired behavior of the Deployment. - - IoK8sApiAppsV1beta1DeploymentSpec(; - minReadySeconds=nothing, - paused=nothing, - progressDeadlineSeconds=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - rollbackTo=nothing, - selector=nothing, - strategy=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - paused::Bool : Indicates that the deployment is paused. - - progressDeadlineSeconds::Int64 : The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. - - replicas::Int64 : Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. - - revisionHistoryLimit::Int64 : The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 2. - - rollbackTo::IoK8sApiAppsV1beta1RollbackConfig - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - strategy::IoK8sApiAppsV1beta1DeploymentStrategy - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - paused::Union{Nothing, Bool} = nothing - progressDeadlineSeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - rollbackTo = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1RollbackConfig } - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - strategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1DeploymentStrategy } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiAppsV1beta1DeploymentSpec(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, rollbackTo, selector, strategy, template, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("paused"), paused) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("progressDeadlineSeconds"), progressDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("rollbackTo"), rollbackTo) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentSpec, Symbol("template"), template) - return new(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, rollbackTo, selector, strategy, template, ) - end -end # type IoK8sApiAppsV1beta1DeploymentSpec - -const _property_types_IoK8sApiAppsV1beta1DeploymentSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("paused")=>"Bool", Symbol("progressDeadlineSeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("rollbackTo")=>"IoK8sApiAppsV1beta1RollbackConfig", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("strategy")=>"IoK8sApiAppsV1beta1DeploymentStrategy", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentSpec) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("progressDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStatus.jl deleted file mode 100644 index c5b1429e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStatus.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentStatus -DeploymentStatus is the most recently observed status of the Deployment. - - IoK8sApiAppsV1beta1DeploymentStatus(; - availableReplicas=nothing, - collisionCount=nothing, - conditions=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - unavailableReplicas=nothing, - updatedReplicas=nothing, - ) - - - availableReplicas::Int64 : Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. - - collisionCount::Int64 : Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. - - conditions::Vector{IoK8sApiAppsV1beta1DeploymentCondition} : Represents the latest available observations of a deployment's current state. - - observedGeneration::Int64 : The generation observed by the deployment controller. - - readyReplicas::Int64 : Total number of ready pods targeted by this deployment. - - replicas::Int64 : Total number of non-terminated pods targeted by this deployment (their labels match the selector). - - unavailableReplicas::Int64 : Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. - - updatedReplicas::Int64 : Total number of non-terminated pods targeted by this deployment that have the desired template spec. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta1DeploymentCondition} } - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - unavailableReplicas::Union{Nothing, Int64} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1DeploymentStatus(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("unavailableReplicas"), unavailableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - end -end # type IoK8sApiAppsV1beta1DeploymentStatus - -const _property_types_IoK8sApiAppsV1beta1DeploymentStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta1DeploymentCondition}", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("unavailableReplicas")=>"Int64", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("unavailableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1DeploymentStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStrategy.jl deleted file mode 100644 index 250d4b95..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1DeploymentStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.DeploymentStrategy -DeploymentStrategy describes how to replace existing pods with new ones. - - IoK8sApiAppsV1beta1DeploymentStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1beta1RollingUpdateDeployment - - type::String : Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1DeploymentStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1RollingUpdateDeployment } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta1DeploymentStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1beta1DeploymentStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1beta1DeploymentStrategy - -const _property_types_IoK8sApiAppsV1beta1DeploymentStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1beta1RollingUpdateDeployment", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1DeploymentStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1DeploymentStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta1DeploymentStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1DeploymentStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollbackConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollbackConfig.jl deleted file mode 100644 index b8fd49fc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollbackConfig.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.RollbackConfig -DEPRECATED. - - IoK8sApiAppsV1beta1RollbackConfig(; - revision=nothing, - ) - - - revision::Int64 : The revision to rollback to. If set to 0, rollback to the last revision. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1RollbackConfig <: OpenAPI.APIModel - revision::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1RollbackConfig(revision, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1RollbackConfig, Symbol("revision"), revision) - return new(revision, ) - end -end # type IoK8sApiAppsV1beta1RollbackConfig - -const _property_types_IoK8sApiAppsV1beta1RollbackConfig = Dict{Symbol,String}(Symbol("revision")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1RollbackConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1RollbackConfig[name]))} - -function check_required(o::IoK8sApiAppsV1beta1RollbackConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1RollbackConfig }, name::Symbol, val) - if name === Symbol("revision") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1RollbackConfig", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateDeployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateDeployment.jl deleted file mode 100644 index 00ba26b4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateDeployment.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.RollingUpdateDeployment -Spec to control the desired behavior of rolling update. - - IoK8sApiAppsV1beta1RollingUpdateDeployment(; - maxSurge=nothing, - maxUnavailable=nothing, - ) - - - maxSurge::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1RollingUpdateDeployment <: OpenAPI.APIModel - maxSurge::Union{Nothing, Any} = nothing - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiAppsV1beta1RollingUpdateDeployment(maxSurge, maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1RollingUpdateDeployment, Symbol("maxSurge"), maxSurge) - OpenAPI.validate_property(IoK8sApiAppsV1beta1RollingUpdateDeployment, Symbol("maxUnavailable"), maxUnavailable) - return new(maxSurge, maxUnavailable, ) - end -end # type IoK8sApiAppsV1beta1RollingUpdateDeployment - -const _property_types_IoK8sApiAppsV1beta1RollingUpdateDeployment = Dict{Symbol,String}(Symbol("maxSurge")=>"Any", Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1RollingUpdateDeployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1RollingUpdateDeployment[name]))} - -function check_required(o::IoK8sApiAppsV1beta1RollingUpdateDeployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1RollingUpdateDeployment }, name::Symbol, val) - if name === Symbol("maxSurge") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1RollingUpdateDeployment", :format, val, "int-or-string") - end - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1RollingUpdateDeployment", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy.jl deleted file mode 100644 index ee0986a9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.RollingUpdateStatefulSetStrategy -RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. - - IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy(; - partition=nothing, - ) - - - partition::Int64 : Partition indicates the ordinal at which the StatefulSet should be partitioned. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy <: OpenAPI.APIModel - partition::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy(partition, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy, Symbol("partition"), partition) - return new(partition, ) - end -end # type IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy - -const _property_types_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy = Dict{Symbol,String}(Symbol("partition")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy }, name::Symbol, val) - if name === Symbol("partition") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Scale.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Scale.jl deleted file mode 100644 index 7f66f5b9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1Scale.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.Scale -Scale represents a scaling request for a resource. - - IoK8sApiAppsV1beta1Scale(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta1ScaleSpec - - status::IoK8sApiAppsV1beta1ScaleStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1Scale <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1ScaleSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1ScaleStatus } - - function IoK8sApiAppsV1beta1Scale(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Scale, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Scale, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Scale, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Scale, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta1Scale, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta1Scale - -const _property_types_IoK8sApiAppsV1beta1Scale = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta1ScaleSpec", Symbol("status")=>"IoK8sApiAppsV1beta1ScaleStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1Scale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1Scale[name]))} - -function check_required(o::IoK8sApiAppsV1beta1Scale) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1Scale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleSpec.jl deleted file mode 100644 index 31efbfde..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleSpec.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.ScaleSpec -ScaleSpec describes the attributes of a scale subresource - - IoK8sApiAppsV1beta1ScaleSpec(; - replicas=nothing, - ) - - - replicas::Int64 : desired number of instances for the scaled object. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1ScaleSpec <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1ScaleSpec(replicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ScaleSpec, Symbol("replicas"), replicas) - return new(replicas, ) - end -end # type IoK8sApiAppsV1beta1ScaleSpec - -const _property_types_IoK8sApiAppsV1beta1ScaleSpec = Dict{Symbol,String}(Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1ScaleSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1ScaleSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta1ScaleSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1ScaleSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1ScaleSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleStatus.jl deleted file mode 100644 index cd3abb1d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1ScaleStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.ScaleStatus -ScaleStatus represents the current status of a scale subresource. - - IoK8sApiAppsV1beta1ScaleStatus(; - replicas=nothing, - selector=nothing, - targetSelector=nothing, - ) - - - replicas::Int64 : actual number of observed instances of the scaled object. - - selector::Dict{String, String} : label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors - - targetSelector::String : label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1ScaleStatus <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - selector::Union{Nothing, Dict{String, String}} = nothing - targetSelector::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta1ScaleStatus(replicas, selector, targetSelector, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ScaleStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ScaleStatus, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta1ScaleStatus, Symbol("targetSelector"), targetSelector) - return new(replicas, selector, targetSelector, ) - end -end # type IoK8sApiAppsV1beta1ScaleStatus - -const _property_types_IoK8sApiAppsV1beta1ScaleStatus = Dict{Symbol,String}(Symbol("replicas")=>"Int64", Symbol("selector")=>"Dict{String, String}", Symbol("targetSelector")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1ScaleStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1ScaleStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta1ScaleStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1ScaleStatus }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1ScaleStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSet.jl deleted file mode 100644 index 4b6a80bd..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSet -DEPRECATED - This group version of StatefulSet is deprecated by apps/v1beta2/StatefulSet. See the release notes for more information. StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. - - IoK8sApiAppsV1beta1StatefulSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta1StatefulSetSpec - - status::IoK8sApiAppsV1beta1StatefulSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1StatefulSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1StatefulSetStatus } - - function IoK8sApiAppsV1beta1StatefulSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta1StatefulSet - -const _property_types_IoK8sApiAppsV1beta1StatefulSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta1StatefulSetSpec", Symbol("status")=>"IoK8sApiAppsV1beta1StatefulSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSet[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetCondition.jl deleted file mode 100644 index e0fd5337..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSetCondition -StatefulSetCondition describes the state of a statefulset at a certain point. - - IoK8sApiAppsV1beta1StatefulSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of statefulset condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta1StatefulSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta1StatefulSetCondition - -const _property_types_IoK8sApiAppsV1beta1StatefulSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetList.jl deleted file mode 100644 index 5eb8ddd3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSetList -StatefulSetList is a collection of StatefulSets. - - IoK8sApiAppsV1beta1StatefulSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta1StatefulSet} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta1StatefulSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta1StatefulSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta1StatefulSetList - -const _property_types_IoK8sApiAppsV1beta1StatefulSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta1StatefulSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSetList[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetSpec.jl deleted file mode 100644 index 2803a062..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetSpec.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSetSpec -A StatefulSetSpec is the specification of a StatefulSet. - - IoK8sApiAppsV1beta1StatefulSetSpec(; - podManagementPolicy=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - serviceName=nothing, - template=nothing, - updateStrategy=nothing, - volumeClaimTemplates=nothing, - ) - - - podManagementPolicy::String : podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. - - replicas::Int64 : replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. - - revisionHistoryLimit::Int64 : revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - serviceName::String : serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. - - template::IoK8sApiCoreV1PodTemplateSpec - - updateStrategy::IoK8sApiAppsV1beta1StatefulSetUpdateStrategy - - volumeClaimTemplates::Vector{IoK8sApiCoreV1PersistentVolumeClaim} : volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSetSpec <: OpenAPI.APIModel - podManagementPolicy::Union{Nothing, String} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - serviceName::Union{Nothing, String} = nothing - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1StatefulSetUpdateStrategy } - volumeClaimTemplates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolumeClaim} } - - function IoK8sApiAppsV1beta1StatefulSetSpec(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("podManagementPolicy"), podManagementPolicy) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("serviceName"), serviceName) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("updateStrategy"), updateStrategy) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetSpec, Symbol("volumeClaimTemplates"), volumeClaimTemplates) - return new(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - end -end # type IoK8sApiAppsV1beta1StatefulSetSpec - -const _property_types_IoK8sApiAppsV1beta1StatefulSetSpec = Dict{Symbol,String}(Symbol("podManagementPolicy")=>"String", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("serviceName")=>"String", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("updateStrategy")=>"IoK8sApiAppsV1beta1StatefulSetUpdateStrategy", Symbol("volumeClaimTemplates")=>"Vector{IoK8sApiCoreV1PersistentVolumeClaim}", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSetSpec) - o.serviceName === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSetSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetStatus.jl deleted file mode 100644 index 4cd53e6f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetStatus.jl +++ /dev/null @@ -1,82 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSetStatus -StatefulSetStatus represents the current state of a StatefulSet. - - IoK8sApiAppsV1beta1StatefulSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentReplicas=nothing, - currentRevision=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - updateRevision=nothing, - updatedReplicas=nothing, - ) - - - collisionCount::Int64 : collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiAppsV1beta1StatefulSetCondition} : Represents the latest available observations of a statefulset's current state. - - currentReplicas::Int64 : currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. - - currentRevision::String : currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). - - observedGeneration::Int64 : observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server. - - readyReplicas::Int64 : readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. - - replicas::Int64 : replicas is the number of Pods created by the StatefulSet controller. - - updateRevision::String : updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) - - updatedReplicas::Int64 : updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta1StatefulSetCondition} } - currentReplicas::Union{Nothing, Int64} = nothing - currentRevision::Union{Nothing, String} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - updateRevision::Union{Nothing, String} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta1StatefulSetStatus(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("currentRevision"), currentRevision) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("updateRevision"), updateRevision) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - end -end # type IoK8sApiAppsV1beta1StatefulSetStatus - -const _property_types_IoK8sApiAppsV1beta1StatefulSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta1StatefulSetCondition}", Symbol("currentReplicas")=>"Int64", Symbol("currentRevision")=>"String", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("updateRevision")=>"String", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta1StatefulSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy.jl deleted file mode 100644 index b78f77da..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta1.StatefulSetUpdateStrategy -StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. - - IoK8sApiAppsV1beta1StatefulSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy - - type::String : Type indicates the type of the StatefulSetUpdateStrategy. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta1StatefulSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta1StatefulSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1beta1StatefulSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1beta1StatefulSetUpdateStrategy - -const _property_types_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta1StatefulSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta1StatefulSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta1StatefulSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta1StatefulSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevision.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevision.jl deleted file mode 100644 index f4e3ab12..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevision.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ControllerRevision -DEPRECATED - This group version of ControllerRevision is deprecated by apps/v1/ControllerRevision. See the release notes for more information. ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. - - IoK8sApiAppsV1beta2ControllerRevision(; - apiVersion=nothing, - data=nothing, - kind=nothing, - metadata=nothing, - revision=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - data::Any : RawExtension is used to hold extensions in external versions. To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. // Internal package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.Object `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // External package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.RawExtension `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // On the wire, the JSON will look something like this: { \"kind\":\"MyAPIObject\", \"apiVersion\":\"v1\", \"myPlugin\": { \"kind\":\"PluginA\", \"aOption\":\"foo\", }, } So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - revision::Int64 : Revision indicates the revision of the state represented by Data. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ControllerRevision <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - data::Union{Nothing, Any} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - revision::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2ControllerRevision(apiVersion, data, kind, metadata, revision, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevision, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevision, Symbol("data"), data) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevision, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevision, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevision, Symbol("revision"), revision) - return new(apiVersion, data, kind, metadata, revision, ) - end -end # type IoK8sApiAppsV1beta2ControllerRevision - -const _property_types_IoK8sApiAppsV1beta2ControllerRevision = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("data")=>"Any", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("revision")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ControllerRevision }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ControllerRevision[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ControllerRevision) - o.revision === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ControllerRevision }, name::Symbol, val) - if name === Symbol("revision") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ControllerRevision", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevisionList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevisionList.jl deleted file mode 100644 index 35766cac..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ControllerRevisionList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ControllerRevisionList -ControllerRevisionList is a resource containing a list of ControllerRevision objects. - - IoK8sApiAppsV1beta2ControllerRevisionList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta2ControllerRevision} : Items is the list of ControllerRevisions - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ControllerRevisionList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2ControllerRevision} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta2ControllerRevisionList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevisionList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevisionList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevisionList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ControllerRevisionList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta2ControllerRevisionList - -const _property_types_IoK8sApiAppsV1beta2ControllerRevisionList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta2ControllerRevision}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ControllerRevisionList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ControllerRevisionList[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ControllerRevisionList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ControllerRevisionList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSet.jl deleted file mode 100644 index 65d67eee..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSet -DEPRECATED - This group version of DaemonSet is deprecated by apps/v1/DaemonSet. See the release notes for more information. DaemonSet represents the configuration of a daemon set. - - IoK8sApiAppsV1beta2DaemonSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta2DaemonSetSpec - - status::IoK8sApiAppsV1beta2DaemonSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DaemonSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DaemonSetStatus } - - function IoK8sApiAppsV1beta2DaemonSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta2DaemonSet - -const _property_types_IoK8sApiAppsV1beta2DaemonSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta2DaemonSetSpec", Symbol("status")=>"IoK8sApiAppsV1beta2DaemonSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSet[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetCondition.jl deleted file mode 100644 index 0a964522..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSetCondition -DaemonSetCondition describes the state of a DaemonSet at a certain point. - - IoK8sApiAppsV1beta2DaemonSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of DaemonSet condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2DaemonSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta2DaemonSetCondition - -const _property_types_IoK8sApiAppsV1beta2DaemonSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetList.jl deleted file mode 100644 index 6f08a06a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSetList -DaemonSetList is a collection of daemon sets. - - IoK8sApiAppsV1beta2DaemonSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta2DaemonSet} : A list of daemon sets. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2DaemonSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta2DaemonSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta2DaemonSetList - -const _property_types_IoK8sApiAppsV1beta2DaemonSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta2DaemonSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSetList[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetSpec.jl deleted file mode 100644 index 15df1368..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetSpec.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSetSpec -DaemonSetSpec is the specification of a daemon set. - - IoK8sApiAppsV1beta2DaemonSetSpec(; - minReadySeconds=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - template=nothing, - updateStrategy=nothing, - ) - - - minReadySeconds::Int64 : The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). - - revisionHistoryLimit::Int64 : The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec - - updateStrategy::IoK8sApiAppsV1beta2DaemonSetUpdateStrategy -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DaemonSetUpdateStrategy } - - function IoK8sApiAppsV1beta2DaemonSetSpec(minReadySeconds, revisionHistoryLimit, selector, template, updateStrategy, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetSpec, Symbol("updateStrategy"), updateStrategy) - return new(minReadySeconds, revisionHistoryLimit, selector, template, updateStrategy, ) - end -end # type IoK8sApiAppsV1beta2DaemonSetSpec - -const _property_types_IoK8sApiAppsV1beta2DaemonSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("updateStrategy")=>"IoK8sApiAppsV1beta2DaemonSetUpdateStrategy", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSetSpec) - o.selector === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetStatus.jl deleted file mode 100644 index 55d0e5f3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetStatus.jl +++ /dev/null @@ -1,98 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSetStatus -DaemonSetStatus represents the current status of a daemon set. - - IoK8sApiAppsV1beta2DaemonSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentNumberScheduled=nothing, - desiredNumberScheduled=nothing, - numberAvailable=nothing, - numberMisscheduled=nothing, - numberReady=nothing, - numberUnavailable=nothing, - observedGeneration=nothing, - updatedNumberScheduled=nothing, - ) - - - collisionCount::Int64 : Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiAppsV1beta2DaemonSetCondition} : Represents the latest available observations of a DaemonSet's current state. - - currentNumberScheduled::Int64 : The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - desiredNumberScheduled::Int64 : The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberAvailable::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) - - numberMisscheduled::Int64 : The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberReady::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. - - numberUnavailable::Int64 : The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) - - observedGeneration::Int64 : The most recent generation observed by the daemon set controller. - - updatedNumberScheduled::Int64 : The total number of nodes that are running updated daemon pod -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2DaemonSetCondition} } - currentNumberScheduled::Union{Nothing, Int64} = nothing - desiredNumberScheduled::Union{Nothing, Int64} = nothing - numberAvailable::Union{Nothing, Int64} = nothing - numberMisscheduled::Union{Nothing, Int64} = nothing - numberReady::Union{Nothing, Int64} = nothing - numberUnavailable::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - updatedNumberScheduled::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2DaemonSetStatus(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("currentNumberScheduled"), currentNumberScheduled) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("desiredNumberScheduled"), desiredNumberScheduled) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("numberAvailable"), numberAvailable) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("numberMisscheduled"), numberMisscheduled) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("numberReady"), numberReady) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("numberUnavailable"), numberUnavailable) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetStatus, Symbol("updatedNumberScheduled"), updatedNumberScheduled) - return new(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - end -end # type IoK8sApiAppsV1beta2DaemonSetStatus - -const _property_types_IoK8sApiAppsV1beta2DaemonSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta2DaemonSetCondition}", Symbol("currentNumberScheduled")=>"Int64", Symbol("desiredNumberScheduled")=>"Int64", Symbol("numberAvailable")=>"Int64", Symbol("numberMisscheduled")=>"Int64", Symbol("numberReady")=>"Int64", Symbol("numberUnavailable")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("updatedNumberScheduled")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSetStatus) - o.currentNumberScheduled === nothing && (return false) - o.desiredNumberScheduled === nothing && (return false) - o.numberMisscheduled === nothing && (return false) - o.numberReady === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("currentNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("desiredNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberAvailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberMisscheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberReady") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int64") - end - if name === Symbol("updatedNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DaemonSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy.jl deleted file mode 100644 index 606fd3ec..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DaemonSetUpdateStrategy -DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. - - IoK8sApiAppsV1beta2DaemonSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1beta2RollingUpdateDaemonSet - - type::String : Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DaemonSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2RollingUpdateDaemonSet } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2DaemonSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DaemonSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1beta2DaemonSetUpdateStrategy - -const _property_types_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1beta2RollingUpdateDaemonSet", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DaemonSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DaemonSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DaemonSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DaemonSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Deployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Deployment.jl deleted file mode 100644 index 5b78beb3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Deployment.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.Deployment -DEPRECATED - This group version of Deployment is deprecated by apps/v1/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. - - IoK8sApiAppsV1beta2Deployment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta2DeploymentSpec - - status::IoK8sApiAppsV1beta2DeploymentStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2Deployment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DeploymentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DeploymentStatus } - - function IoK8sApiAppsV1beta2Deployment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Deployment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Deployment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Deployment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Deployment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Deployment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta2Deployment - -const _property_types_IoK8sApiAppsV1beta2Deployment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta2DeploymentSpec", Symbol("status")=>"IoK8sApiAppsV1beta2DeploymentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2Deployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2Deployment[name]))} - -function check_required(o::IoK8sApiAppsV1beta2Deployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2Deployment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentCondition.jl deleted file mode 100644 index fc28d3e4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DeploymentCondition -DeploymentCondition describes the state of a deployment at a certain point. - - IoK8sApiAppsV1beta2DeploymentCondition(; - lastTransitionTime=nothing, - lastUpdateTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastUpdateTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of deployment condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DeploymentCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - lastUpdateTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2DeploymentCondition(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("lastUpdateTime"), lastUpdateTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentCondition, Symbol("type"), type) - return new(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta2DeploymentCondition - -const _property_types_IoK8sApiAppsV1beta2DeploymentCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("lastUpdateTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DeploymentCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DeploymentCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DeploymentCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DeploymentCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentCondition", :format, val, "date-time") - end - if name === Symbol("lastUpdateTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentList.jl deleted file mode 100644 index 8b0cedb3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DeploymentList -DeploymentList is a list of Deployments. - - IoK8sApiAppsV1beta2DeploymentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta2Deployment} : Items is the list of Deployments. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DeploymentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2Deployment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta2DeploymentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta2DeploymentList - -const _property_types_IoK8sApiAppsV1beta2DeploymentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta2Deployment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DeploymentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DeploymentList[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DeploymentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DeploymentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentSpec.jl deleted file mode 100644 index 1beb6eed..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentSpec.jl +++ /dev/null @@ -1,73 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DeploymentSpec -DeploymentSpec is the specification of the desired behavior of the Deployment. - - IoK8sApiAppsV1beta2DeploymentSpec(; - minReadySeconds=nothing, - paused=nothing, - progressDeadlineSeconds=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - strategy=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - paused::Bool : Indicates that the deployment is paused. - - progressDeadlineSeconds::Int64 : The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. - - replicas::Int64 : Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. - - revisionHistoryLimit::Int64 : The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - strategy::IoK8sApiAppsV1beta2DeploymentStrategy - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DeploymentSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - paused::Union{Nothing, Bool} = nothing - progressDeadlineSeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - strategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2DeploymentStrategy } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiAppsV1beta2DeploymentSpec(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, selector, strategy, template, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("paused"), paused) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("progressDeadlineSeconds"), progressDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentSpec, Symbol("template"), template) - return new(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, selector, strategy, template, ) - end -end # type IoK8sApiAppsV1beta2DeploymentSpec - -const _property_types_IoK8sApiAppsV1beta2DeploymentSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("paused")=>"Bool", Symbol("progressDeadlineSeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("strategy")=>"IoK8sApiAppsV1beta2DeploymentStrategy", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DeploymentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DeploymentSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DeploymentSpec) - o.selector === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DeploymentSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentSpec", :format, val, "int32") - end - if name === Symbol("progressDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStatus.jl deleted file mode 100644 index aaeffe92..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStatus.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DeploymentStatus -DeploymentStatus is the most recently observed status of the Deployment. - - IoK8sApiAppsV1beta2DeploymentStatus(; - availableReplicas=nothing, - collisionCount=nothing, - conditions=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - unavailableReplicas=nothing, - updatedReplicas=nothing, - ) - - - availableReplicas::Int64 : Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. - - collisionCount::Int64 : Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. - - conditions::Vector{IoK8sApiAppsV1beta2DeploymentCondition} : Represents the latest available observations of a deployment's current state. - - observedGeneration::Int64 : The generation observed by the deployment controller. - - readyReplicas::Int64 : Total number of ready pods targeted by this deployment. - - replicas::Int64 : Total number of non-terminated pods targeted by this deployment (their labels match the selector). - - unavailableReplicas::Int64 : Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. - - updatedReplicas::Int64 : Total number of non-terminated pods targeted by this deployment that have the desired template spec. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DeploymentStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2DeploymentCondition} } - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - unavailableReplicas::Union{Nothing, Int64} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2DeploymentStatus(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("unavailableReplicas"), unavailableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - end -end # type IoK8sApiAppsV1beta2DeploymentStatus - -const _property_types_IoK8sApiAppsV1beta2DeploymentStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta2DeploymentCondition}", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("unavailableReplicas")=>"Int64", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DeploymentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DeploymentStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DeploymentStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DeploymentStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end - if name === Symbol("unavailableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2DeploymentStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStrategy.jl deleted file mode 100644 index a8f5f53e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2DeploymentStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.DeploymentStrategy -DeploymentStrategy describes how to replace existing pods with new ones. - - IoK8sApiAppsV1beta2DeploymentStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1beta2RollingUpdateDeployment - - type::String : Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2DeploymentStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2RollingUpdateDeployment } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2DeploymentStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1beta2DeploymentStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1beta2DeploymentStrategy - -const _property_types_IoK8sApiAppsV1beta2DeploymentStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1beta2RollingUpdateDeployment", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2DeploymentStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2DeploymentStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta2DeploymentStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2DeploymentStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSet.jl deleted file mode 100644 index fcb170e2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ReplicaSet -DEPRECATED - This group version of ReplicaSet is deprecated by apps/v1/ReplicaSet. See the release notes for more information. ReplicaSet ensures that a specified number of pod replicas are running at any given time. - - IoK8sApiAppsV1beta2ReplicaSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta2ReplicaSetSpec - - status::IoK8sApiAppsV1beta2ReplicaSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ReplicaSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2ReplicaSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2ReplicaSetStatus } - - function IoK8sApiAppsV1beta2ReplicaSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta2ReplicaSet - -const _property_types_IoK8sApiAppsV1beta2ReplicaSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta2ReplicaSetSpec", Symbol("status")=>"IoK8sApiAppsV1beta2ReplicaSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ReplicaSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ReplicaSet[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ReplicaSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ReplicaSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetCondition.jl deleted file mode 100644 index b9665bab..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ReplicaSetCondition -ReplicaSetCondition describes the state of a replica set at a certain point. - - IoK8sApiAppsV1beta2ReplicaSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of replica set condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ReplicaSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2ReplicaSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta2ReplicaSetCondition - -const _property_types_IoK8sApiAppsV1beta2ReplicaSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ReplicaSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ReplicaSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ReplicaSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ReplicaSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetList.jl deleted file mode 100644 index cbc0bc39..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ReplicaSetList -ReplicaSetList is a collection of ReplicaSets. - - IoK8sApiAppsV1beta2ReplicaSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta2ReplicaSet} : List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ReplicaSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2ReplicaSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta2ReplicaSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta2ReplicaSetList - -const _property_types_IoK8sApiAppsV1beta2ReplicaSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta2ReplicaSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ReplicaSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ReplicaSetList[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ReplicaSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ReplicaSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetSpec.jl deleted file mode 100644 index 4e82d113..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetSpec.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ReplicaSetSpec -ReplicaSetSpec is the specification of a ReplicaSet. - - IoK8sApiAppsV1beta2ReplicaSetSpec(; - minReadySeconds=nothing, - replicas=nothing, - selector=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - replicas::Int64 : Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ReplicaSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiAppsV1beta2ReplicaSetSpec(minReadySeconds, replicas, selector, template, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetSpec, Symbol("template"), template) - return new(minReadySeconds, replicas, selector, template, ) - end -end # type IoK8sApiAppsV1beta2ReplicaSetSpec - -const _property_types_IoK8sApiAppsV1beta2ReplicaSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ReplicaSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ReplicaSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ReplicaSetSpec) - o.selector === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ReplicaSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetStatus.jl deleted file mode 100644 index caa92eb1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ReplicaSetStatus.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ReplicaSetStatus -ReplicaSetStatus represents the current status of a ReplicaSet. - - IoK8sApiAppsV1beta2ReplicaSetStatus(; - availableReplicas=nothing, - conditions=nothing, - fullyLabeledReplicas=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - ) - - - availableReplicas::Int64 : The number of available replicas (ready for at least minReadySeconds) for this replica set. - - conditions::Vector{IoK8sApiAppsV1beta2ReplicaSetCondition} : Represents the latest available observations of a replica set's current state. - - fullyLabeledReplicas::Int64 : The number of pods that have labels matching the labels of the pod template of the replicaset. - - observedGeneration::Int64 : ObservedGeneration reflects the generation of the most recently observed ReplicaSet. - - readyReplicas::Int64 : The number of ready replicas for this replica set. - - replicas::Int64 : Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ReplicaSetStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2ReplicaSetCondition} } - fullyLabeledReplicas::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2ReplicaSetStatus(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("fullyLabeledReplicas"), fullyLabeledReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ReplicaSetStatus, Symbol("replicas"), replicas) - return new(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - end -end # type IoK8sApiAppsV1beta2ReplicaSetStatus - -const _property_types_IoK8sApiAppsV1beta2ReplicaSetStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta2ReplicaSetCondition}", Symbol("fullyLabeledReplicas")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ReplicaSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ReplicaSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ReplicaSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ReplicaSetStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("fullyLabeledReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ReplicaSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDaemonSet.jl deleted file mode 100644 index 6b4be0b9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDaemonSet.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.RollingUpdateDaemonSet -Spec to control the desired behavior of daemon set rolling update. - - IoK8sApiAppsV1beta2RollingUpdateDaemonSet(; - maxUnavailable=nothing, - ) - - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2RollingUpdateDaemonSet <: OpenAPI.APIModel - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiAppsV1beta2RollingUpdateDaemonSet(maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2RollingUpdateDaemonSet, Symbol("maxUnavailable"), maxUnavailable) - return new(maxUnavailable, ) - end -end # type IoK8sApiAppsV1beta2RollingUpdateDaemonSet - -const _property_types_IoK8sApiAppsV1beta2RollingUpdateDaemonSet = Dict{Symbol,String}(Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2RollingUpdateDaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2RollingUpdateDaemonSet[name]))} - -function check_required(o::IoK8sApiAppsV1beta2RollingUpdateDaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2RollingUpdateDaemonSet }, name::Symbol, val) - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2RollingUpdateDaemonSet", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDeployment.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDeployment.jl deleted file mode 100644 index 69972516..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateDeployment.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.RollingUpdateDeployment -Spec to control the desired behavior of rolling update. - - IoK8sApiAppsV1beta2RollingUpdateDeployment(; - maxSurge=nothing, - maxUnavailable=nothing, - ) - - - maxSurge::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2RollingUpdateDeployment <: OpenAPI.APIModel - maxSurge::Union{Nothing, Any} = nothing - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiAppsV1beta2RollingUpdateDeployment(maxSurge, maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2RollingUpdateDeployment, Symbol("maxSurge"), maxSurge) - OpenAPI.validate_property(IoK8sApiAppsV1beta2RollingUpdateDeployment, Symbol("maxUnavailable"), maxUnavailable) - return new(maxSurge, maxUnavailable, ) - end -end # type IoK8sApiAppsV1beta2RollingUpdateDeployment - -const _property_types_IoK8sApiAppsV1beta2RollingUpdateDeployment = Dict{Symbol,String}(Symbol("maxSurge")=>"Any", Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2RollingUpdateDeployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2RollingUpdateDeployment[name]))} - -function check_required(o::IoK8sApiAppsV1beta2RollingUpdateDeployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2RollingUpdateDeployment }, name::Symbol, val) - if name === Symbol("maxSurge") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2RollingUpdateDeployment", :format, val, "int-or-string") - end - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2RollingUpdateDeployment", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy.jl deleted file mode 100644 index 9d917566..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.RollingUpdateStatefulSetStrategy -RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. - - IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy(; - partition=nothing, - ) - - - partition::Int64 : Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy <: OpenAPI.APIModel - partition::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy(partition, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy, Symbol("partition"), partition) - return new(partition, ) - end -end # type IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy - -const _property_types_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy = Dict{Symbol,String}(Symbol("partition")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy }, name::Symbol, val) - if name === Symbol("partition") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Scale.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Scale.jl deleted file mode 100644 index f318521a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2Scale.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.Scale -Scale represents a scaling request for a resource. - - IoK8sApiAppsV1beta2Scale(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta2ScaleSpec - - status::IoK8sApiAppsV1beta2ScaleStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2Scale <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2ScaleSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2ScaleStatus } - - function IoK8sApiAppsV1beta2Scale(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Scale, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Scale, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Scale, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Scale, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta2Scale, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta2Scale - -const _property_types_IoK8sApiAppsV1beta2Scale = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta2ScaleSpec", Symbol("status")=>"IoK8sApiAppsV1beta2ScaleStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2Scale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2Scale[name]))} - -function check_required(o::IoK8sApiAppsV1beta2Scale) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2Scale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleSpec.jl deleted file mode 100644 index f2c83381..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleSpec.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ScaleSpec -ScaleSpec describes the attributes of a scale subresource - - IoK8sApiAppsV1beta2ScaleSpec(; - replicas=nothing, - ) - - - replicas::Int64 : desired number of instances for the scaled object. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ScaleSpec <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2ScaleSpec(replicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ScaleSpec, Symbol("replicas"), replicas) - return new(replicas, ) - end -end # type IoK8sApiAppsV1beta2ScaleSpec - -const _property_types_IoK8sApiAppsV1beta2ScaleSpec = Dict{Symbol,String}(Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ScaleSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ScaleSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ScaleSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ScaleSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ScaleSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleStatus.jl deleted file mode 100644 index 7df6ee61..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2ScaleStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.ScaleStatus -ScaleStatus represents the current status of a scale subresource. - - IoK8sApiAppsV1beta2ScaleStatus(; - replicas=nothing, - selector=nothing, - targetSelector=nothing, - ) - - - replicas::Int64 : actual number of observed instances of the scaled object. - - selector::Dict{String, String} : label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors - - targetSelector::String : label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2ScaleStatus <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - selector::Union{Nothing, Dict{String, String}} = nothing - targetSelector::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2ScaleStatus(replicas, selector, targetSelector, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ScaleStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ScaleStatus, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta2ScaleStatus, Symbol("targetSelector"), targetSelector) - return new(replicas, selector, targetSelector, ) - end -end # type IoK8sApiAppsV1beta2ScaleStatus - -const _property_types_IoK8sApiAppsV1beta2ScaleStatus = Dict{Symbol,String}(Symbol("replicas")=>"Int64", Symbol("selector")=>"Dict{String, String}", Symbol("targetSelector")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2ScaleStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2ScaleStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta2ScaleStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2ScaleStatus }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2ScaleStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSet.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSet.jl deleted file mode 100644 index d0fee00e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSet -DEPRECATED - This group version of StatefulSet is deprecated by apps/v1/StatefulSet. See the release notes for more information. StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. - - IoK8sApiAppsV1beta2StatefulSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAppsV1beta2StatefulSetSpec - - status::IoK8sApiAppsV1beta2StatefulSetStatus -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2StatefulSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2StatefulSetStatus } - - function IoK8sApiAppsV1beta2StatefulSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAppsV1beta2StatefulSet - -const _property_types_IoK8sApiAppsV1beta2StatefulSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAppsV1beta2StatefulSetSpec", Symbol("status")=>"IoK8sApiAppsV1beta2StatefulSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSet[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetCondition.jl deleted file mode 100644 index e5f7433b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSetCondition -StatefulSetCondition describes the state of a statefulset at a certain point. - - IoK8sApiAppsV1beta2StatefulSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of statefulset condition. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2StatefulSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAppsV1beta2StatefulSetCondition - -const _property_types_IoK8sApiAppsV1beta2StatefulSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSetCondition[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetList.jl deleted file mode 100644 index d65d7749..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSetList -StatefulSetList is a collection of StatefulSets. - - IoK8sApiAppsV1beta2StatefulSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAppsV1beta2StatefulSet} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2StatefulSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAppsV1beta2StatefulSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAppsV1beta2StatefulSetList - -const _property_types_IoK8sApiAppsV1beta2StatefulSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAppsV1beta2StatefulSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSetList[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetSpec.jl deleted file mode 100644 index e729896c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetSpec.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSetSpec -A StatefulSetSpec is the specification of a StatefulSet. - - IoK8sApiAppsV1beta2StatefulSetSpec(; - podManagementPolicy=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - serviceName=nothing, - template=nothing, - updateStrategy=nothing, - volumeClaimTemplates=nothing, - ) - - - podManagementPolicy::String : podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. - - replicas::Int64 : replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. - - revisionHistoryLimit::Int64 : revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - serviceName::String : serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. - - template::IoK8sApiCoreV1PodTemplateSpec - - updateStrategy::IoK8sApiAppsV1beta2StatefulSetUpdateStrategy - - volumeClaimTemplates::Vector{IoK8sApiCoreV1PersistentVolumeClaim} : volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSetSpec <: OpenAPI.APIModel - podManagementPolicy::Union{Nothing, String} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - serviceName::Union{Nothing, String} = nothing - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2StatefulSetUpdateStrategy } - volumeClaimTemplates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolumeClaim} } - - function IoK8sApiAppsV1beta2StatefulSetSpec(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("podManagementPolicy"), podManagementPolicy) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("serviceName"), serviceName) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("updateStrategy"), updateStrategy) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetSpec, Symbol("volumeClaimTemplates"), volumeClaimTemplates) - return new(podManagementPolicy, replicas, revisionHistoryLimit, selector, serviceName, template, updateStrategy, volumeClaimTemplates, ) - end -end # type IoK8sApiAppsV1beta2StatefulSetSpec - -const _property_types_IoK8sApiAppsV1beta2StatefulSetSpec = Dict{Symbol,String}(Symbol("podManagementPolicy")=>"String", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("serviceName")=>"String", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("updateStrategy")=>"IoK8sApiAppsV1beta2StatefulSetUpdateStrategy", Symbol("volumeClaimTemplates")=>"Vector{IoK8sApiCoreV1PersistentVolumeClaim}", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSetSpec[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSetSpec) - o.selector === nothing && (return false) - o.serviceName === nothing && (return false) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSetSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetStatus.jl deleted file mode 100644 index 89c77873..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetStatus.jl +++ /dev/null @@ -1,82 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSetStatus -StatefulSetStatus represents the current state of a StatefulSet. - - IoK8sApiAppsV1beta2StatefulSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentReplicas=nothing, - currentRevision=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - updateRevision=nothing, - updatedReplicas=nothing, - ) - - - collisionCount::Int64 : collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiAppsV1beta2StatefulSetCondition} : Represents the latest available observations of a statefulset's current state. - - currentReplicas::Int64 : currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. - - currentRevision::String : currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). - - observedGeneration::Int64 : observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server. - - readyReplicas::Int64 : readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. - - replicas::Int64 : replicas is the number of Pods created by the StatefulSet controller. - - updateRevision::String : updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) - - updatedReplicas::Int64 : updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAppsV1beta2StatefulSetCondition} } - currentReplicas::Union{Nothing, Int64} = nothing - currentRevision::Union{Nothing, String} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - updateRevision::Union{Nothing, String} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAppsV1beta2StatefulSetStatus(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("currentRevision"), currentRevision) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("updateRevision"), updateRevision) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(collisionCount, conditions, currentReplicas, currentRevision, observedGeneration, readyReplicas, replicas, updateRevision, updatedReplicas, ) - end -end # type IoK8sApiAppsV1beta2StatefulSetStatus - -const _property_types_IoK8sApiAppsV1beta2StatefulSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiAppsV1beta2StatefulSetCondition}", Symbol("currentReplicas")=>"Int64", Symbol("currentRevision")=>"String", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("updateRevision")=>"String", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSetStatus[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiAppsV1beta2StatefulSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy.jl deleted file mode 100644 index 915bacfc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.apps.v1beta2.StatefulSetUpdateStrategy -StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. - - IoK8sApiAppsV1beta2StatefulSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy - - type::String : Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiAppsV1beta2StatefulSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy } - type::Union{Nothing, String} = nothing - - function IoK8sApiAppsV1beta2StatefulSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiAppsV1beta2StatefulSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiAppsV1beta2StatefulSetUpdateStrategy - -const _property_types_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAppsV1beta2StatefulSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAppsV1beta2StatefulSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiAppsV1beta2StatefulSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAppsV1beta2StatefulSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSink.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSink.jl deleted file mode 100644 index 50d62a24..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSink.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.AuditSink -AuditSink represents a cluster level audit sink - - IoK8sApiAuditregistrationV1alpha1AuditSink(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuditregistrationV1alpha1AuditSinkSpec -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1AuditSink <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1AuditSinkSpec } - - function IoK8sApiAuditregistrationV1alpha1AuditSink(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSink, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSink, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSink, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSink, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiAuditregistrationV1alpha1AuditSink - -const _property_types_IoK8sApiAuditregistrationV1alpha1AuditSink = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuditregistrationV1alpha1AuditSinkSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSink }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1AuditSink[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1AuditSink) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSink }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkList.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkList.jl deleted file mode 100644 index a9290035..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.AuditSinkList -AuditSinkList is a list of AuditSink items. - - IoK8sApiAuditregistrationV1alpha1AuditSinkList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAuditregistrationV1alpha1AuditSink} : List of audit configurations. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1AuditSinkList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAuditregistrationV1alpha1AuditSink} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAuditregistrationV1alpha1AuditSinkList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAuditregistrationV1alpha1AuditSinkList - -const _property_types_IoK8sApiAuditregistrationV1alpha1AuditSinkList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAuditregistrationV1alpha1AuditSink}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSinkList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1AuditSinkList[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1AuditSinkList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSinkList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec.jl deleted file mode 100644 index a1862bdf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.AuditSinkSpec -AuditSinkSpec holds the spec for the audit sink - - IoK8sApiAuditregistrationV1alpha1AuditSinkSpec(; - policy=nothing, - webhook=nothing, - ) - - - policy::IoK8sApiAuditregistrationV1alpha1Policy - - webhook::IoK8sApiAuditregistrationV1alpha1Webhook -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1AuditSinkSpec <: OpenAPI.APIModel - policy = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1Policy } - webhook = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1Webhook } - - function IoK8sApiAuditregistrationV1alpha1AuditSinkSpec(policy, webhook, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkSpec, Symbol("policy"), policy) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1AuditSinkSpec, Symbol("webhook"), webhook) - return new(policy, webhook, ) - end -end # type IoK8sApiAuditregistrationV1alpha1AuditSinkSpec - -const _property_types_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec = Dict{Symbol,String}(Symbol("policy")=>"IoK8sApiAuditregistrationV1alpha1Policy", Symbol("webhook")=>"IoK8sApiAuditregistrationV1alpha1Webhook", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSinkSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1AuditSinkSpec[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1AuditSinkSpec) - o.policy === nothing && (return false) - o.webhook === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1AuditSinkSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Policy.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Policy.jl deleted file mode 100644 index 6fb9092a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Policy.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.Policy -Policy defines the configuration of how audit events are logged - - IoK8sApiAuditregistrationV1alpha1Policy(; - level=nothing, - stages=nothing, - ) - - - level::String : The Level that all requests are recorded at. available options: None, Metadata, Request, RequestResponse required - - stages::Vector{String} : Stages is a list of stages for which events are created. -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1Policy <: OpenAPI.APIModel - level::Union{Nothing, String} = nothing - stages::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiAuditregistrationV1alpha1Policy(level, stages, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1Policy, Symbol("level"), level) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1Policy, Symbol("stages"), stages) - return new(level, stages, ) - end -end # type IoK8sApiAuditregistrationV1alpha1Policy - -const _property_types_IoK8sApiAuditregistrationV1alpha1Policy = Dict{Symbol,String}(Symbol("level")=>"String", Symbol("stages")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1Policy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1Policy[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1Policy) - o.level === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1Policy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1ServiceReference.jl deleted file mode 100644 index fee0f195..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1ServiceReference.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sApiAuditregistrationV1alpha1ServiceReference(; - name=nothing, - namespace=nothing, - path=nothing, - port=nothing, - ) - - - name::String : `name` is the name of the service. Required - - namespace::String : `namespace` is the namespace of the service. Required - - path::String : `path` is an optional URL path which will be sent in any request to this service. - - port::Int64 : If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sApiAuditregistrationV1alpha1ServiceReference(name, namespace, path, port, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1ServiceReference, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1ServiceReference, Symbol("port"), port) - return new(name, namespace, path, port, ) - end -end # type IoK8sApiAuditregistrationV1alpha1ServiceReference - -const _property_types_IoK8sApiAuditregistrationV1alpha1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("path")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1ServiceReference[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1ServiceReference) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiAuditregistrationV1alpha1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Webhook.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Webhook.jl deleted file mode 100644 index ae2f27be..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1Webhook.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.Webhook -Webhook holds the configuration of the webhook - - IoK8sApiAuditregistrationV1alpha1Webhook(; - clientConfig=nothing, - throttle=nothing, - ) - - - clientConfig::IoK8sApiAuditregistrationV1alpha1WebhookClientConfig - - throttle::IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1Webhook <: OpenAPI.APIModel - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1WebhookClientConfig } - throttle = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig } - - function IoK8sApiAuditregistrationV1alpha1Webhook(clientConfig, throttle, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1Webhook, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1Webhook, Symbol("throttle"), throttle) - return new(clientConfig, throttle, ) - end -end # type IoK8sApiAuditregistrationV1alpha1Webhook - -const _property_types_IoK8sApiAuditregistrationV1alpha1Webhook = Dict{Symbol,String}(Symbol("clientConfig")=>"IoK8sApiAuditregistrationV1alpha1WebhookClientConfig", Symbol("throttle")=>"IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1Webhook }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1Webhook[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1Webhook) - o.clientConfig === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1Webhook }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig.jl deleted file mode 100644 index fa185ee4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.WebhookClientConfig -WebhookClientConfig contains the information to make a connection with the webhook - - IoK8sApiAuditregistrationV1alpha1WebhookClientConfig(; - caBundle=nothing, - service=nothing, - url=nothing, - ) - - - caBundle::Vector{UInt8} : `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. - - service::IoK8sApiAuditregistrationV1alpha1ServiceReference - - url::String : `url` gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1WebhookClientConfig <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sApiAuditregistrationV1alpha1ServiceReference } - url::Union{Nothing, String} = nothing - - function IoK8sApiAuditregistrationV1alpha1WebhookClientConfig(caBundle, service, url, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1WebhookClientConfig, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1WebhookClientConfig, Symbol("service"), service) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1WebhookClientConfig, Symbol("url"), url) - return new(caBundle, service, url, ) - end -end # type IoK8sApiAuditregistrationV1alpha1WebhookClientConfig - -const _property_types_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("service")=>"IoK8sApiAuditregistrationV1alpha1ServiceReference", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1WebhookClientConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1WebhookClientConfig[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1WebhookClientConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1WebhookClientConfig }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAuditregistrationV1alpha1WebhookClientConfig", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiAuditregistrationV1alpha1WebhookClientConfig", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig.jl deleted file mode 100644 index 7edff0f4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.auditregistration.v1alpha1.WebhookThrottleConfig -WebhookThrottleConfig holds the configuration for throttling events - - IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig(; - burst=nothing, - qps=nothing, - ) - - - burst::Int64 : ThrottleBurst is the maximum number of events sent at the same moment default 15 QPS - - qps::Int64 : ThrottleQPS maximum number of batches per second default 10 QPS -""" -Base.@kwdef mutable struct IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig <: OpenAPI.APIModel - burst::Union{Nothing, Int64} = nothing - qps::Union{Nothing, Int64} = nothing - - function IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig(burst, qps, ) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig, Symbol("burst"), burst) - OpenAPI.validate_property(IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig, Symbol("qps"), qps) - return new(burst, qps, ) - end -end # type IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig - -const _property_types_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig = Dict{Symbol,String}(Symbol("burst")=>"Int64", Symbol("qps")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig[name]))} - -function check_required(o::IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig }, name::Symbol, val) - if name === Symbol("burst") - OpenAPI.validate_param(name, "IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig", :format, val, "int64") - end - if name === Symbol("qps") - OpenAPI.validate_param(name, "IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1BoundObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1BoundObjectReference.jl deleted file mode 100644 index 5fff37fa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1BoundObjectReference.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.BoundObjectReference -BoundObjectReference is a reference to an object that a token is bound to. - - IoK8sApiAuthenticationV1BoundObjectReference(; - apiVersion=nothing, - kind=nothing, - name=nothing, - uid=nothing, - ) - - - apiVersion::String : API version of the referent. - - kind::String : Kind of the referent. Valid kinds are 'Pod' and 'Secret'. - - name::String : Name of the referent. - - uid::String : UID of the referent. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1BoundObjectReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1BoundObjectReference(apiVersion, kind, name, uid, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1BoundObjectReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthenticationV1BoundObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthenticationV1BoundObjectReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAuthenticationV1BoundObjectReference, Symbol("uid"), uid) - return new(apiVersion, kind, name, uid, ) - end -end # type IoK8sApiAuthenticationV1BoundObjectReference - -const _property_types_IoK8sApiAuthenticationV1BoundObjectReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1BoundObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1BoundObjectReference[name]))} - -function check_required(o::IoK8sApiAuthenticationV1BoundObjectReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1BoundObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequest.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequest.jl deleted file mode 100644 index e72f37ed..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequest.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenRequest -TokenRequest requests a token for a given service account. - - IoK8sApiAuthenticationV1TokenRequest(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthenticationV1TokenRequestSpec - - status::IoK8sApiAuthenticationV1TokenRequestStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenRequest <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1TokenRequestSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1TokenRequestStatus } - - function IoK8sApiAuthenticationV1TokenRequest(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequest, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequest, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequest, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequest, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequest, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthenticationV1TokenRequest - -const _property_types_IoK8sApiAuthenticationV1TokenRequest = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthenticationV1TokenRequestSpec", Symbol("status")=>"IoK8sApiAuthenticationV1TokenRequestStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenRequest }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenRequest[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenRequest) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenRequest }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestSpec.jl deleted file mode 100644 index 19b6a5a4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestSpec.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenRequestSpec -TokenRequestSpec contains client provided parameters of a token request. - - IoK8sApiAuthenticationV1TokenRequestSpec(; - audiences=nothing, - boundObjectRef=nothing, - expirationSeconds=nothing, - ) - - - audiences::Vector{String} : Audiences are the intendend audiences of the token. A recipient of a token must identitfy themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. - - boundObjectRef::IoK8sApiAuthenticationV1BoundObjectReference - - expirationSeconds::Int64 : ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenRequestSpec <: OpenAPI.APIModel - audiences::Union{Nothing, Vector{String}} = nothing - boundObjectRef = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1BoundObjectReference } - expirationSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiAuthenticationV1TokenRequestSpec(audiences, boundObjectRef, expirationSeconds, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequestSpec, Symbol("audiences"), audiences) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequestSpec, Symbol("boundObjectRef"), boundObjectRef) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequestSpec, Symbol("expirationSeconds"), expirationSeconds) - return new(audiences, boundObjectRef, expirationSeconds, ) - end -end # type IoK8sApiAuthenticationV1TokenRequestSpec - -const _property_types_IoK8sApiAuthenticationV1TokenRequestSpec = Dict{Symbol,String}(Symbol("audiences")=>"Vector{String}", Symbol("boundObjectRef")=>"IoK8sApiAuthenticationV1BoundObjectReference", Symbol("expirationSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenRequestSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenRequestSpec[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenRequestSpec) - o.audiences === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenRequestSpec }, name::Symbol, val) - if name === Symbol("expirationSeconds") - OpenAPI.validate_param(name, "IoK8sApiAuthenticationV1TokenRequestSpec", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestStatus.jl deleted file mode 100644 index 5a9c270b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenRequestStatus.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenRequestStatus -TokenRequestStatus is the result of a token request. - - IoK8sApiAuthenticationV1TokenRequestStatus(; - expirationTimestamp=nothing, - token=nothing, - ) - - - expirationTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - token::String : Token is the opaque bearer token. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenRequestStatus <: OpenAPI.APIModel - expirationTimestamp::Union{Nothing, ZonedDateTime} = nothing - token::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1TokenRequestStatus(expirationTimestamp, token, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequestStatus, Symbol("expirationTimestamp"), expirationTimestamp) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenRequestStatus, Symbol("token"), token) - return new(expirationTimestamp, token, ) - end -end # type IoK8sApiAuthenticationV1TokenRequestStatus - -const _property_types_IoK8sApiAuthenticationV1TokenRequestStatus = Dict{Symbol,String}(Symbol("expirationTimestamp")=>"ZonedDateTime", Symbol("token")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenRequestStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenRequestStatus[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenRequestStatus) - o.expirationTimestamp === nothing && (return false) - o.token === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenRequestStatus }, name::Symbol, val) - if name === Symbol("expirationTimestamp") - OpenAPI.validate_param(name, "IoK8sApiAuthenticationV1TokenRequestStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReview.jl deleted file mode 100644 index acacd2fa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenReview -TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. - - IoK8sApiAuthenticationV1TokenReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthenticationV1TokenReviewSpec - - status::IoK8sApiAuthenticationV1TokenReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1TokenReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1TokenReviewStatus } - - function IoK8sApiAuthenticationV1TokenReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthenticationV1TokenReview - -const _property_types_IoK8sApiAuthenticationV1TokenReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthenticationV1TokenReviewSpec", Symbol("status")=>"IoK8sApiAuthenticationV1TokenReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenReview[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewSpec.jl deleted file mode 100644 index 60f01e6b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenReviewSpec -TokenReviewSpec is a description of the token authentication request. - - IoK8sApiAuthenticationV1TokenReviewSpec(; - audiences=nothing, - token=nothing, - ) - - - audiences::Vector{String} : Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. - - token::String : Token is the opaque bearer token. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenReviewSpec <: OpenAPI.APIModel - audiences::Union{Nothing, Vector{String}} = nothing - token::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1TokenReviewSpec(audiences, token, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewSpec, Symbol("audiences"), audiences) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewSpec, Symbol("token"), token) - return new(audiences, token, ) - end -end # type IoK8sApiAuthenticationV1TokenReviewSpec - -const _property_types_IoK8sApiAuthenticationV1TokenReviewSpec = Dict{Symbol,String}(Symbol("audiences")=>"Vector{String}", Symbol("token")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewStatus.jl deleted file mode 100644 index 864e7b47..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1TokenReviewStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.TokenReviewStatus -TokenReviewStatus is the result of the token authentication request. - - IoK8sApiAuthenticationV1TokenReviewStatus(; - audiences=nothing, - authenticated=nothing, - error=nothing, - user=nothing, - ) - - - audiences::Vector{String} : Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is \"true\", the token is valid against the audience of the Kubernetes API server. - - authenticated::Bool : Authenticated indicates that the token was associated with a known user. - - error::String : Error indicates that the token couldn't be checked - - user::IoK8sApiAuthenticationV1UserInfo -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1TokenReviewStatus <: OpenAPI.APIModel - audiences::Union{Nothing, Vector{String}} = nothing - authenticated::Union{Nothing, Bool} = nothing - error::Union{Nothing, String} = nothing - user = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1UserInfo } - - function IoK8sApiAuthenticationV1TokenReviewStatus(audiences, authenticated, error, user, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewStatus, Symbol("audiences"), audiences) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewStatus, Symbol("authenticated"), authenticated) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewStatus, Symbol("error"), error) - OpenAPI.validate_property(IoK8sApiAuthenticationV1TokenReviewStatus, Symbol("user"), user) - return new(audiences, authenticated, error, user, ) - end -end # type IoK8sApiAuthenticationV1TokenReviewStatus - -const _property_types_IoK8sApiAuthenticationV1TokenReviewStatus = Dict{Symbol,String}(Symbol("audiences")=>"Vector{String}", Symbol("authenticated")=>"Bool", Symbol("error")=>"String", Symbol("user")=>"IoK8sApiAuthenticationV1UserInfo", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1TokenReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1TokenReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthenticationV1TokenReviewStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1TokenReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1UserInfo.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1UserInfo.jl deleted file mode 100644 index 07f0bd7d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1UserInfo.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1.UserInfo -UserInfo holds the information about the user needed to implement the user.Info interface. - - IoK8sApiAuthenticationV1UserInfo(; - extra=nothing, - groups=nothing, - uid=nothing, - username=nothing, - ) - - - extra::Dict{String, Vector{String}} : Any additional information provided by the authenticator. - - groups::Vector{String} : The names of groups this user is a part of. - - uid::String : A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. - - username::String : The name that uniquely identifies this user among all active users. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1UserInfo <: OpenAPI.APIModel - extra::Union{Nothing, Dict{String, Vector{String}}} = nothing - groups::Union{Nothing, Vector{String}} = nothing - uid::Union{Nothing, String} = nothing - username::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1UserInfo(extra, groups, uid, username, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1UserInfo, Symbol("extra"), extra) - OpenAPI.validate_property(IoK8sApiAuthenticationV1UserInfo, Symbol("groups"), groups) - OpenAPI.validate_property(IoK8sApiAuthenticationV1UserInfo, Symbol("uid"), uid) - OpenAPI.validate_property(IoK8sApiAuthenticationV1UserInfo, Symbol("username"), username) - return new(extra, groups, uid, username, ) - end -end # type IoK8sApiAuthenticationV1UserInfo - -const _property_types_IoK8sApiAuthenticationV1UserInfo = Dict{Symbol,String}(Symbol("extra")=>"Dict{String, Vector{String}}", Symbol("groups")=>"Vector{String}", Symbol("uid")=>"String", Symbol("username")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1UserInfo }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1UserInfo[name]))} - -function check_required(o::IoK8sApiAuthenticationV1UserInfo) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1UserInfo }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReview.jl deleted file mode 100644 index b72875bf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1beta1.TokenReview -TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. - - IoK8sApiAuthenticationV1beta1TokenReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthenticationV1beta1TokenReviewSpec - - status::IoK8sApiAuthenticationV1beta1TokenReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1beta1TokenReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1beta1TokenReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1beta1TokenReviewStatus } - - function IoK8sApiAuthenticationV1beta1TokenReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthenticationV1beta1TokenReview - -const _property_types_IoK8sApiAuthenticationV1beta1TokenReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthenticationV1beta1TokenReviewSpec", Symbol("status")=>"IoK8sApiAuthenticationV1beta1TokenReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1beta1TokenReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1beta1TokenReview[name]))} - -function check_required(o::IoK8sApiAuthenticationV1beta1TokenReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1beta1TokenReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewSpec.jl deleted file mode 100644 index f2cbe0ec..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1beta1.TokenReviewSpec -TokenReviewSpec is a description of the token authentication request. - - IoK8sApiAuthenticationV1beta1TokenReviewSpec(; - audiences=nothing, - token=nothing, - ) - - - audiences::Vector{String} : Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. - - token::String : Token is the opaque bearer token. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1beta1TokenReviewSpec <: OpenAPI.APIModel - audiences::Union{Nothing, Vector{String}} = nothing - token::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1beta1TokenReviewSpec(audiences, token, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewSpec, Symbol("audiences"), audiences) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewSpec, Symbol("token"), token) - return new(audiences, token, ) - end -end # type IoK8sApiAuthenticationV1beta1TokenReviewSpec - -const _property_types_IoK8sApiAuthenticationV1beta1TokenReviewSpec = Dict{Symbol,String}(Symbol("audiences")=>"Vector{String}", Symbol("token")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1beta1TokenReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1beta1TokenReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthenticationV1beta1TokenReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1beta1TokenReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewStatus.jl deleted file mode 100644 index fdcc97bf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1TokenReviewStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1beta1.TokenReviewStatus -TokenReviewStatus is the result of the token authentication request. - - IoK8sApiAuthenticationV1beta1TokenReviewStatus(; - audiences=nothing, - authenticated=nothing, - error=nothing, - user=nothing, - ) - - - audiences::Vector{String} : Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is \"true\", the token is valid against the audience of the Kubernetes API server. - - authenticated::Bool : Authenticated indicates that the token was associated with a known user. - - error::String : Error indicates that the token couldn't be checked - - user::IoK8sApiAuthenticationV1beta1UserInfo -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1beta1TokenReviewStatus <: OpenAPI.APIModel - audiences::Union{Nothing, Vector{String}} = nothing - authenticated::Union{Nothing, Bool} = nothing - error::Union{Nothing, String} = nothing - user = nothing # spec type: Union{ Nothing, IoK8sApiAuthenticationV1beta1UserInfo } - - function IoK8sApiAuthenticationV1beta1TokenReviewStatus(audiences, authenticated, error, user, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewStatus, Symbol("audiences"), audiences) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewStatus, Symbol("authenticated"), authenticated) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewStatus, Symbol("error"), error) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1TokenReviewStatus, Symbol("user"), user) - return new(audiences, authenticated, error, user, ) - end -end # type IoK8sApiAuthenticationV1beta1TokenReviewStatus - -const _property_types_IoK8sApiAuthenticationV1beta1TokenReviewStatus = Dict{Symbol,String}(Symbol("audiences")=>"Vector{String}", Symbol("authenticated")=>"Bool", Symbol("error")=>"String", Symbol("user")=>"IoK8sApiAuthenticationV1beta1UserInfo", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1beta1TokenReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1beta1TokenReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthenticationV1beta1TokenReviewStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1beta1TokenReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1UserInfo.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1UserInfo.jl deleted file mode 100644 index f9947890..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthenticationV1beta1UserInfo.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authentication.v1beta1.UserInfo -UserInfo holds the information about the user needed to implement the user.Info interface. - - IoK8sApiAuthenticationV1beta1UserInfo(; - extra=nothing, - groups=nothing, - uid=nothing, - username=nothing, - ) - - - extra::Dict{String, Vector{String}} : Any additional information provided by the authenticator. - - groups::Vector{String} : The names of groups this user is a part of. - - uid::String : A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. - - username::String : The name that uniquely identifies this user among all active users. -""" -Base.@kwdef mutable struct IoK8sApiAuthenticationV1beta1UserInfo <: OpenAPI.APIModel - extra::Union{Nothing, Dict{String, Vector{String}}} = nothing - groups::Union{Nothing, Vector{String}} = nothing - uid::Union{Nothing, String} = nothing - username::Union{Nothing, String} = nothing - - function IoK8sApiAuthenticationV1beta1UserInfo(extra, groups, uid, username, ) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1UserInfo, Symbol("extra"), extra) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1UserInfo, Symbol("groups"), groups) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1UserInfo, Symbol("uid"), uid) - OpenAPI.validate_property(IoK8sApiAuthenticationV1beta1UserInfo, Symbol("username"), username) - return new(extra, groups, uid, username, ) - end -end # type IoK8sApiAuthenticationV1beta1UserInfo - -const _property_types_IoK8sApiAuthenticationV1beta1UserInfo = Dict{Symbol,String}(Symbol("extra")=>"Dict{String, Vector{String}}", Symbol("groups")=>"Vector{String}", Symbol("uid")=>"String", Symbol("username")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthenticationV1beta1UserInfo }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthenticationV1beta1UserInfo[name]))} - -function check_required(o::IoK8sApiAuthenticationV1beta1UserInfo) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthenticationV1beta1UserInfo }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1LocalSubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1LocalSubjectAccessReview.jl deleted file mode 100644 index 1f6232ab..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1LocalSubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.LocalSubjectAccessReview -LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. - - IoK8sApiAuthorizationV1LocalSubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1SubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1LocalSubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1LocalSubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1LocalSubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1LocalSubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1LocalSubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1LocalSubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1LocalSubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1LocalSubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1LocalSubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1SubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1LocalSubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1LocalSubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1LocalSubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1LocalSubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceAttributes.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceAttributes.jl deleted file mode 100644 index 8caae159..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceAttributes.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.NonResourceAttributes -NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface - - IoK8sApiAuthorizationV1NonResourceAttributes(; - path=nothing, - verb=nothing, - ) - - - path::String : Path is the URL path of the request - - verb::String : Verb is the standard HTTP verb -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1NonResourceAttributes <: OpenAPI.APIModel - path::Union{Nothing, String} = nothing - verb::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1NonResourceAttributes(path, verb, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1NonResourceAttributes, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiAuthorizationV1NonResourceAttributes, Symbol("verb"), verb) - return new(path, verb, ) - end -end # type IoK8sApiAuthorizationV1NonResourceAttributes - -const _property_types_IoK8sApiAuthorizationV1NonResourceAttributes = Dict{Symbol,String}(Symbol("path")=>"String", Symbol("verb")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1NonResourceAttributes }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1NonResourceAttributes[name]))} - -function check_required(o::IoK8sApiAuthorizationV1NonResourceAttributes) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1NonResourceAttributes }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceRule.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceRule.jl deleted file mode 100644 index fe7d062a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1NonResourceRule.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.NonResourceRule -NonResourceRule holds information that describes a rule for the non-resource - - IoK8sApiAuthorizationV1NonResourceRule(; - nonResourceURLs=nothing, - verbs=nothing, - ) - - - nonResourceURLs::Vector{String} : NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. \"*\" means all. - - verbs::Vector{String} : Verb is a list of kubernetes non-resource API verbs, like: get, post, put, delete, patch, head, options. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1NonResourceRule <: OpenAPI.APIModel - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiAuthorizationV1NonResourceRule(nonResourceURLs, verbs, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1NonResourceRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiAuthorizationV1NonResourceRule, Symbol("verbs"), verbs) - return new(nonResourceURLs, verbs, ) - end -end # type IoK8sApiAuthorizationV1NonResourceRule - -const _property_types_IoK8sApiAuthorizationV1NonResourceRule = Dict{Symbol,String}(Symbol("nonResourceURLs")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1NonResourceRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1NonResourceRule[name]))} - -function check_required(o::IoK8sApiAuthorizationV1NonResourceRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1NonResourceRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceAttributes.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceAttributes.jl deleted file mode 100644 index b1340956..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceAttributes.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.ResourceAttributes -ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface - - IoK8sApiAuthorizationV1ResourceAttributes(; - group=nothing, - name=nothing, - namespace=nothing, - resource=nothing, - subresource=nothing, - verb=nothing, - version=nothing, - ) - - - group::String : Group is the API Group of the Resource. \"*\" means all. - - name::String : Name is the name of the resource being requested for a \"get\" or deleted for a \"delete\". \"\" (empty) means all. - - namespace::String : Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces \"\" (empty) is defaulted for LocalSubjectAccessReviews \"\" (empty) is empty for cluster-scoped resources \"\" (empty) means \"all\" for namespace scoped resources from a SubjectAccessReview or SelfSubjectAccessReview - - resource::String : Resource is one of the existing resource types. \"*\" means all. - - subresource::String : Subresource is one of the existing resource types. \"\" means none. - - verb::String : Verb is a kubernetes resource API verb, like: get, list, watch, create, update, delete, proxy. \"*\" means all. - - version::String : Version is the API Version of the Resource. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1ResourceAttributes <: OpenAPI.APIModel - group::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - resource::Union{Nothing, String} = nothing - subresource::Union{Nothing, String} = nothing - verb::Union{Nothing, String} = nothing - version::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1ResourceAttributes(group, name, namespace, resource, subresource, verb, version, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("subresource"), subresource) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("verb"), verb) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceAttributes, Symbol("version"), version) - return new(group, name, namespace, resource, subresource, verb, version, ) - end -end # type IoK8sApiAuthorizationV1ResourceAttributes - -const _property_types_IoK8sApiAuthorizationV1ResourceAttributes = Dict{Symbol,String}(Symbol("group")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("resource")=>"String", Symbol("subresource")=>"String", Symbol("verb")=>"String", Symbol("version")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1ResourceAttributes }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1ResourceAttributes[name]))} - -function check_required(o::IoK8sApiAuthorizationV1ResourceAttributes) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1ResourceAttributes }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceRule.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceRule.jl deleted file mode 100644 index b6c9babf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1ResourceRule.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.ResourceRule -ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. - - IoK8sApiAuthorizationV1ResourceRule(; - apiGroups=nothing, - resourceNames=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"*\" means all. - - resourceNames::Vector{String} : ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. \"*\" means all. - - resources::Vector{String} : Resources is a list of resources this rule applies to. \"*\" means all in the specified apiGroups. \"*/foo\" represents the subresource 'foo' for all resources in the specified apiGroups. - - verbs::Vector{String} : Verb is a list of kubernetes resource API verbs, like: get, list, watch, create, update, delete, proxy. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1ResourceRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - resourceNames::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiAuthorizationV1ResourceRule(apiGroups, resourceNames, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceRule, Symbol("resourceNames"), resourceNames) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiAuthorizationV1ResourceRule, Symbol("verbs"), verbs) - return new(apiGroups, resourceNames, resources, verbs, ) - end -end # type IoK8sApiAuthorizationV1ResourceRule - -const _property_types_IoK8sApiAuthorizationV1ResourceRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("resourceNames")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1ResourceRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1ResourceRule[name]))} - -function check_required(o::IoK8sApiAuthorizationV1ResourceRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1ResourceRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReview.jl deleted file mode 100644 index a023e72c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SelfSubjectAccessReview -SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means \"in all namespaces\". Self is a special case, because users should always be able to check whether they can perform an action - - IoK8sApiAuthorizationV1SelfSubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SelfSubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1SelfSubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1SelfSubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1SelfSubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SelfSubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SelfSubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SelfSubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SelfSubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec.jl deleted file mode 100644 index 37d4cc34..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SelfSubjectAccessReviewSpec -SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set - - IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec(; - nonResourceAttributes=nothing, - resourceAttributes=nothing, - ) - - - nonResourceAttributes::IoK8sApiAuthorizationV1NonResourceAttributes - - resourceAttributes::IoK8sApiAuthorizationV1ResourceAttributes -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec <: OpenAPI.APIModel - nonResourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1NonResourceAttributes } - resourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1ResourceAttributes } - - function IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec(nonResourceAttributes, resourceAttributes, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec, Symbol("nonResourceAttributes"), nonResourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec, Symbol("resourceAttributes"), resourceAttributes) - return new(nonResourceAttributes, resourceAttributes, ) - end -end # type IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec - -const _property_types_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec = Dict{Symbol,String}(Symbol("nonResourceAttributes")=>"IoK8sApiAuthorizationV1NonResourceAttributes", Symbol("resourceAttributes")=>"IoK8sApiAuthorizationV1ResourceAttributes", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReview.jl deleted file mode 100644 index f1d55133..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SelfSubjectRulesReview -SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. - - IoK8sApiAuthorizationV1SelfSubjectRulesReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec - - status::IoK8sApiAuthorizationV1SubjectRulesReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SelfSubjectRulesReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectRulesReviewStatus } - - function IoK8sApiAuthorizationV1SelfSubjectRulesReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1SelfSubjectRulesReview - -const _property_types_IoK8sApiAuthorizationV1SelfSubjectRulesReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1SubjectRulesReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SelfSubjectRulesReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SelfSubjectRulesReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SelfSubjectRulesReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SelfSubjectRulesReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec.jl deleted file mode 100644 index 0dec4d68..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec.jl +++ /dev/null @@ -1,30 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SelfSubjectRulesReviewSpec - - IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec(; - namespace=nothing, - ) - - - namespace::String : Namespace to evaluate rules for. Required. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec <: OpenAPI.APIModel - namespace::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec(namespace, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec, Symbol("namespace"), namespace) - return new(namespace, ) - end -end # type IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec - -const _property_types_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec = Dict{Symbol,String}(Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReview.jl deleted file mode 100644 index 93c6a131..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SubjectAccessReview -SubjectAccessReview checks whether or not a user or group can perform an action. - - IoK8sApiAuthorizationV1SubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1SubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1SubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1SubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1SubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1SubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewSpec.jl deleted file mode 100644 index f4a1e428..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewSpec.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SubjectAccessReviewSpec -SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set - - IoK8sApiAuthorizationV1SubjectAccessReviewSpec(; - extra=nothing, - groups=nothing, - nonResourceAttributes=nothing, - resourceAttributes=nothing, - uid=nothing, - user=nothing, - ) - - - extra::Dict{String, Vector{String}} : Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. - - groups::Vector{String} : Groups is the groups you're testing for. - - nonResourceAttributes::IoK8sApiAuthorizationV1NonResourceAttributes - - resourceAttributes::IoK8sApiAuthorizationV1ResourceAttributes - - uid::String : UID information about the requesting user. - - user::String : User is the user you're testing for. If you specify \"User\" but not \"Groups\", then is it interpreted as \"What if User were not a member of any groups -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SubjectAccessReviewSpec <: OpenAPI.APIModel - extra::Union{Nothing, Dict{String, Vector{String}}} = nothing - groups::Union{Nothing, Vector{String}} = nothing - nonResourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1NonResourceAttributes } - resourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1ResourceAttributes } - uid::Union{Nothing, String} = nothing - user::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1SubjectAccessReviewSpec(extra, groups, nonResourceAttributes, resourceAttributes, uid, user, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("extra"), extra) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("groups"), groups) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("nonResourceAttributes"), nonResourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("resourceAttributes"), resourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("uid"), uid) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewSpec, Symbol("user"), user) - return new(extra, groups, nonResourceAttributes, resourceAttributes, uid, user, ) - end -end # type IoK8sApiAuthorizationV1SubjectAccessReviewSpec - -const _property_types_IoK8sApiAuthorizationV1SubjectAccessReviewSpec = Dict{Symbol,String}(Symbol("extra")=>"Dict{String, Vector{String}}", Symbol("groups")=>"Vector{String}", Symbol("nonResourceAttributes")=>"IoK8sApiAuthorizationV1NonResourceAttributes", Symbol("resourceAttributes")=>"IoK8sApiAuthorizationV1ResourceAttributes", Symbol("uid")=>"String", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SubjectAccessReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SubjectAccessReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SubjectAccessReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SubjectAccessReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewStatus.jl deleted file mode 100644 index 565e39f1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectAccessReviewStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SubjectAccessReviewStatus -SubjectAccessReviewStatus - - IoK8sApiAuthorizationV1SubjectAccessReviewStatus(; - allowed=nothing, - denied=nothing, - evaluationError=nothing, - reason=nothing, - ) - - - allowed::Bool : Allowed is required. True if the action would be allowed, false otherwise. - - denied::Bool : Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. - - evaluationError::String : EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. - - reason::String : Reason is optional. It indicates why a request was allowed or denied. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SubjectAccessReviewStatus <: OpenAPI.APIModel - allowed::Union{Nothing, Bool} = nothing - denied::Union{Nothing, Bool} = nothing - evaluationError::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1SubjectAccessReviewStatus(allowed, denied, evaluationError, reason, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewStatus, Symbol("allowed"), allowed) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewStatus, Symbol("denied"), denied) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewStatus, Symbol("evaluationError"), evaluationError) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectAccessReviewStatus, Symbol("reason"), reason) - return new(allowed, denied, evaluationError, reason, ) - end -end # type IoK8sApiAuthorizationV1SubjectAccessReviewStatus - -const _property_types_IoK8sApiAuthorizationV1SubjectAccessReviewStatus = Dict{Symbol,String}(Symbol("allowed")=>"Bool", Symbol("denied")=>"Bool", Symbol("evaluationError")=>"String", Symbol("reason")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SubjectAccessReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SubjectAccessReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SubjectAccessReviewStatus) - o.allowed === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SubjectAccessReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectRulesReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectRulesReviewStatus.jl deleted file mode 100644 index 7db1b8e2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1SubjectRulesReviewStatus.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1.SubjectRulesReviewStatus -SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. - - IoK8sApiAuthorizationV1SubjectRulesReviewStatus(; - evaluationError=nothing, - incomplete=nothing, - nonResourceRules=nothing, - resourceRules=nothing, - ) - - - evaluationError::String : EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. - - incomplete::Bool : Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation. - - nonResourceRules::Vector{IoK8sApiAuthorizationV1NonResourceRule} : NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. - - resourceRules::Vector{IoK8sApiAuthorizationV1ResourceRule} : ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1SubjectRulesReviewStatus <: OpenAPI.APIModel - evaluationError::Union{Nothing, String} = nothing - incomplete::Union{Nothing, Bool} = nothing - nonResourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAuthorizationV1NonResourceRule} } - resourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAuthorizationV1ResourceRule} } - - function IoK8sApiAuthorizationV1SubjectRulesReviewStatus(evaluationError, incomplete, nonResourceRules, resourceRules, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectRulesReviewStatus, Symbol("evaluationError"), evaluationError) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectRulesReviewStatus, Symbol("incomplete"), incomplete) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectRulesReviewStatus, Symbol("nonResourceRules"), nonResourceRules) - OpenAPI.validate_property(IoK8sApiAuthorizationV1SubjectRulesReviewStatus, Symbol("resourceRules"), resourceRules) - return new(evaluationError, incomplete, nonResourceRules, resourceRules, ) - end -end # type IoK8sApiAuthorizationV1SubjectRulesReviewStatus - -const _property_types_IoK8sApiAuthorizationV1SubjectRulesReviewStatus = Dict{Symbol,String}(Symbol("evaluationError")=>"String", Symbol("incomplete")=>"Bool", Symbol("nonResourceRules")=>"Vector{IoK8sApiAuthorizationV1NonResourceRule}", Symbol("resourceRules")=>"Vector{IoK8sApiAuthorizationV1ResourceRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1SubjectRulesReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1SubjectRulesReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthorizationV1SubjectRulesReviewStatus) - o.incomplete === nothing && (return false) - o.nonResourceRules === nothing && (return false) - o.resourceRules === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1SubjectRulesReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview.jl deleted file mode 100644 index 1caf218b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.LocalSubjectAccessReview -LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. - - IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceAttributes.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceAttributes.jl deleted file mode 100644 index c5b42f1b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceAttributes.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.NonResourceAttributes -NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface - - IoK8sApiAuthorizationV1beta1NonResourceAttributes(; - path=nothing, - verb=nothing, - ) - - - path::String : Path is the URL path of the request - - verb::String : Verb is the standard HTTP verb -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1NonResourceAttributes <: OpenAPI.APIModel - path::Union{Nothing, String} = nothing - verb::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1beta1NonResourceAttributes(path, verb, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1NonResourceAttributes, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1NonResourceAttributes, Symbol("verb"), verb) - return new(path, verb, ) - end -end # type IoK8sApiAuthorizationV1beta1NonResourceAttributes - -const _property_types_IoK8sApiAuthorizationV1beta1NonResourceAttributes = Dict{Symbol,String}(Symbol("path")=>"String", Symbol("verb")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1NonResourceAttributes }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1NonResourceAttributes[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1NonResourceAttributes) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1NonResourceAttributes }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceRule.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceRule.jl deleted file mode 100644 index 1dcb416b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1NonResourceRule.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.NonResourceRule -NonResourceRule holds information that describes a rule for the non-resource - - IoK8sApiAuthorizationV1beta1NonResourceRule(; - nonResourceURLs=nothing, - verbs=nothing, - ) - - - nonResourceURLs::Vector{String} : NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. \"*\" means all. - - verbs::Vector{String} : Verb is a list of kubernetes non-resource API verbs, like: get, post, put, delete, patch, head, options. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1NonResourceRule <: OpenAPI.APIModel - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiAuthorizationV1beta1NonResourceRule(nonResourceURLs, verbs, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1NonResourceRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1NonResourceRule, Symbol("verbs"), verbs) - return new(nonResourceURLs, verbs, ) - end -end # type IoK8sApiAuthorizationV1beta1NonResourceRule - -const _property_types_IoK8sApiAuthorizationV1beta1NonResourceRule = Dict{Symbol,String}(Symbol("nonResourceURLs")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1NonResourceRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1NonResourceRule[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1NonResourceRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1NonResourceRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceAttributes.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceAttributes.jl deleted file mode 100644 index be7e3af8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceAttributes.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.ResourceAttributes -ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface - - IoK8sApiAuthorizationV1beta1ResourceAttributes(; - group=nothing, - name=nothing, - namespace=nothing, - resource=nothing, - subresource=nothing, - verb=nothing, - version=nothing, - ) - - - group::String : Group is the API Group of the Resource. \"*\" means all. - - name::String : Name is the name of the resource being requested for a \"get\" or deleted for a \"delete\". \"\" (empty) means all. - - namespace::String : Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces \"\" (empty) is defaulted for LocalSubjectAccessReviews \"\" (empty) is empty for cluster-scoped resources \"\" (empty) means \"all\" for namespace scoped resources from a SubjectAccessReview or SelfSubjectAccessReview - - resource::String : Resource is one of the existing resource types. \"*\" means all. - - subresource::String : Subresource is one of the existing resource types. \"\" means none. - - verb::String : Verb is a kubernetes resource API verb, like: get, list, watch, create, update, delete, proxy. \"*\" means all. - - version::String : Version is the API Version of the Resource. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1ResourceAttributes <: OpenAPI.APIModel - group::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - resource::Union{Nothing, String} = nothing - subresource::Union{Nothing, String} = nothing - verb::Union{Nothing, String} = nothing - version::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1beta1ResourceAttributes(group, name, namespace, resource, subresource, verb, version, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("subresource"), subresource) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("verb"), verb) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceAttributes, Symbol("version"), version) - return new(group, name, namespace, resource, subresource, verb, version, ) - end -end # type IoK8sApiAuthorizationV1beta1ResourceAttributes - -const _property_types_IoK8sApiAuthorizationV1beta1ResourceAttributes = Dict{Symbol,String}(Symbol("group")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("resource")=>"String", Symbol("subresource")=>"String", Symbol("verb")=>"String", Symbol("version")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1ResourceAttributes }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1ResourceAttributes[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1ResourceAttributes) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1ResourceAttributes }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceRule.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceRule.jl deleted file mode 100644 index e6b75493..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1ResourceRule.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.ResourceRule -ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. - - IoK8sApiAuthorizationV1beta1ResourceRule(; - apiGroups=nothing, - resourceNames=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"*\" means all. - - resourceNames::Vector{String} : ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. \"*\" means all. - - resources::Vector{String} : Resources is a list of resources this rule applies to. \"*\" means all in the specified apiGroups. \"*/foo\" represents the subresource 'foo' for all resources in the specified apiGroups. - - verbs::Vector{String} : Verb is a list of kubernetes resource API verbs, like: get, list, watch, create, update, delete, proxy. \"*\" means all. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1ResourceRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - resourceNames::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiAuthorizationV1beta1ResourceRule(apiGroups, resourceNames, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceRule, Symbol("resourceNames"), resourceNames) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1ResourceRule, Symbol("verbs"), verbs) - return new(apiGroups, resourceNames, resources, verbs, ) - end -end # type IoK8sApiAuthorizationV1beta1ResourceRule - -const _property_types_IoK8sApiAuthorizationV1beta1ResourceRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("resourceNames")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1ResourceRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1ResourceRule[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1ResourceRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1ResourceRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview.jl deleted file mode 100644 index 2d34286e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SelfSubjectAccessReview -SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means \"in all namespaces\". Self is a special case, because users should always be able to check whether they can perform an action - - IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec.jl deleted file mode 100644 index 00f49f74..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SelfSubjectAccessReviewSpec -SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set - - IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec(; - nonResourceAttributes=nothing, - resourceAttributes=nothing, - ) - - - nonResourceAttributes::IoK8sApiAuthorizationV1beta1NonResourceAttributes - - resourceAttributes::IoK8sApiAuthorizationV1beta1ResourceAttributes -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec <: OpenAPI.APIModel - nonResourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1NonResourceAttributes } - resourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1ResourceAttributes } - - function IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec(nonResourceAttributes, resourceAttributes, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec, Symbol("nonResourceAttributes"), nonResourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec, Symbol("resourceAttributes"), resourceAttributes) - return new(nonResourceAttributes, resourceAttributes, ) - end -end # type IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec - -const _property_types_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec = Dict{Symbol,String}(Symbol("nonResourceAttributes")=>"IoK8sApiAuthorizationV1beta1NonResourceAttributes", Symbol("resourceAttributes")=>"IoK8sApiAuthorizationV1beta1ResourceAttributes", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview.jl deleted file mode 100644 index ac65d000..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SelfSubjectRulesReview -SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. - - IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec - - status::IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus } - - function IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview - -const _property_types_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec.jl deleted file mode 100644 index 1b3d5f48..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec.jl +++ /dev/null @@ -1,30 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SelfSubjectRulesReviewSpec - - IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec(; - namespace=nothing, - ) - - - namespace::String : Namespace to evaluate rules for. Required. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec <: OpenAPI.APIModel - namespace::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec(namespace, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec, Symbol("namespace"), namespace) - return new(namespace, ) - end -end # type IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec - -const _property_types_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec = Dict{Symbol,String}(Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReview.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReview.jl deleted file mode 100644 index 6e23da95..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReview.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SubjectAccessReview -SubjectAccessReview checks whether or not a user or group can perform an action. - - IoK8sApiAuthorizationV1beta1SubjectAccessReview(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec - - status::IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SubjectAccessReview <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus } - - function IoK8sApiAuthorizationV1beta1SubjectAccessReview(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReview, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReview, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReview, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReview, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReview, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAuthorizationV1beta1SubjectAccessReview - -const _property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReview = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec", Symbol("status")=>"IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReview }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReview[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SubjectAccessReview) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReview }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec.jl deleted file mode 100644 index 18c90ec0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SubjectAccessReviewSpec -SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set - - IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec(; - extra=nothing, - group=nothing, - nonResourceAttributes=nothing, - resourceAttributes=nothing, - uid=nothing, - user=nothing, - ) - - - extra::Dict{String, Vector{String}} : Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. - - group::Vector{String} : Groups is the groups you're testing for. - - nonResourceAttributes::IoK8sApiAuthorizationV1beta1NonResourceAttributes - - resourceAttributes::IoK8sApiAuthorizationV1beta1ResourceAttributes - - uid::String : UID information about the requesting user. - - user::String : User is the user you're testing for. If you specify \"User\" but not \"Group\", then is it interpreted as \"What if User were not a member of any groups -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec <: OpenAPI.APIModel - extra::Union{Nothing, Dict{String, Vector{String}}} = nothing - group::Union{Nothing, Vector{String}} = nothing - nonResourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1NonResourceAttributes } - resourceAttributes = nothing # spec type: Union{ Nothing, IoK8sApiAuthorizationV1beta1ResourceAttributes } - uid::Union{Nothing, String} = nothing - user::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec(extra, group, nonResourceAttributes, resourceAttributes, uid, user, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("extra"), extra) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("nonResourceAttributes"), nonResourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("resourceAttributes"), resourceAttributes) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("uid"), uid) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec, Symbol("user"), user) - return new(extra, group, nonResourceAttributes, resourceAttributes, uid, user, ) - end -end # type IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec - -const _property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec = Dict{Symbol,String}(Symbol("extra")=>"Dict{String, Vector{String}}", Symbol("group")=>"Vector{String}", Symbol("nonResourceAttributes")=>"IoK8sApiAuthorizationV1beta1NonResourceAttributes", Symbol("resourceAttributes")=>"IoK8sApiAuthorizationV1beta1ResourceAttributes", Symbol("uid")=>"String", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus.jl deleted file mode 100644 index a349c493..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SubjectAccessReviewStatus -SubjectAccessReviewStatus - - IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus(; - allowed=nothing, - denied=nothing, - evaluationError=nothing, - reason=nothing, - ) - - - allowed::Bool : Allowed is required. True if the action would be allowed, false otherwise. - - denied::Bool : Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. - - evaluationError::String : EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. - - reason::String : Reason is optional. It indicates why a request was allowed or denied. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus <: OpenAPI.APIModel - allowed::Union{Nothing, Bool} = nothing - denied::Union{Nothing, Bool} = nothing - evaluationError::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - - function IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus(allowed, denied, evaluationError, reason, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus, Symbol("allowed"), allowed) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus, Symbol("denied"), denied) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus, Symbol("evaluationError"), evaluationError) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus, Symbol("reason"), reason) - return new(allowed, denied, evaluationError, reason, ) - end -end # type IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus - -const _property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus = Dict{Symbol,String}(Symbol("allowed")=>"Bool", Symbol("denied")=>"Bool", Symbol("evaluationError")=>"String", Symbol("reason")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus) - o.allowed === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus.jl deleted file mode 100644 index 7e77f79d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.authorization.v1beta1.SubjectRulesReviewStatus -SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. - - IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus(; - evaluationError=nothing, - incomplete=nothing, - nonResourceRules=nothing, - resourceRules=nothing, - ) - - - evaluationError::String : EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. - - incomplete::Bool : Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation. - - nonResourceRules::Vector{IoK8sApiAuthorizationV1beta1NonResourceRule} : NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. - - resourceRules::Vector{IoK8sApiAuthorizationV1beta1ResourceRule} : ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. -""" -Base.@kwdef mutable struct IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus <: OpenAPI.APIModel - evaluationError::Union{Nothing, String} = nothing - incomplete::Union{Nothing, Bool} = nothing - nonResourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAuthorizationV1beta1NonResourceRule} } - resourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAuthorizationV1beta1ResourceRule} } - - function IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus(evaluationError, incomplete, nonResourceRules, resourceRules, ) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus, Symbol("evaluationError"), evaluationError) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus, Symbol("incomplete"), incomplete) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus, Symbol("nonResourceRules"), nonResourceRules) - OpenAPI.validate_property(IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus, Symbol("resourceRules"), resourceRules) - return new(evaluationError, incomplete, nonResourceRules, resourceRules, ) - end -end # type IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus - -const _property_types_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus = Dict{Symbol,String}(Symbol("evaluationError")=>"String", Symbol("incomplete")=>"Bool", Symbol("nonResourceRules")=>"Vector{IoK8sApiAuthorizationV1beta1NonResourceRule}", Symbol("resourceRules")=>"Vector{IoK8sApiAuthorizationV1beta1ResourceRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus[name]))} - -function check_required(o::IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus) - o.incomplete === nothing && (return false) - o.nonResourceRules === nothing && (return false) - o.resourceRules === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1CrossVersionObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1CrossVersionObjectReference.jl deleted file mode 100644 index ec9eadc2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1CrossVersionObjectReference.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.CrossVersionObjectReference -CrossVersionObjectReference contains enough information to let you identify the referred resource. - - IoK8sApiAutoscalingV1CrossVersionObjectReference(; - apiVersion=nothing, - kind=nothing, - name=nothing, - ) - - - apiVersion::String : API version of the referent - - kind::String : Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\" - - name::String : Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1CrossVersionObjectReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV1CrossVersionObjectReference(apiVersion, kind, name, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1CrossVersionObjectReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV1CrossVersionObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV1CrossVersionObjectReference, Symbol("name"), name) - return new(apiVersion, kind, name, ) - end -end # type IoK8sApiAutoscalingV1CrossVersionObjectReference - -const _property_types_IoK8sApiAutoscalingV1CrossVersionObjectReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1CrossVersionObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1CrossVersionObjectReference[name]))} - -function check_required(o::IoK8sApiAutoscalingV1CrossVersionObjectReference) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1CrossVersionObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscaler.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscaler.jl deleted file mode 100644 index 2b484628..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscaler.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler -configuration of a horizontal pod autoscaler. - - IoK8sApiAutoscalingV1HorizontalPodAutoscaler(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec - - status::IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1HorizontalPodAutoscaler <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus } - - function IoK8sApiAutoscalingV1HorizontalPodAutoscaler(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAutoscalingV1HorizontalPodAutoscaler - -const _property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscaler = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec", Symbol("status")=>"IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscaler }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscaler[name]))} - -function check_required(o::IoK8sApiAutoscalingV1HorizontalPodAutoscaler) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscaler }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList.jl deleted file mode 100644 index acb63c21..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList -list of horizontal pod autoscaler objects. - - IoK8sApiAutoscalingV1HorizontalPodAutoscalerList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAutoscalingV1HorizontalPodAutoscaler} : list of horizontal pod autoscaler objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV1HorizontalPodAutoscaler} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAutoscalingV1HorizontalPodAutoscalerList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAutoscalingV1HorizontalPodAutoscalerList - -const _property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAutoscalingV1HorizontalPodAutoscaler}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerList[name]))} - -function check_required(o::IoK8sApiAutoscalingV1HorizontalPodAutoscalerList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec.jl deleted file mode 100644 index f40a5164..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec -specification of a horizontal pod autoscaler. - - IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec(; - maxReplicas=nothing, - minReplicas=nothing, - scaleTargetRef=nothing, - targetCPUUtilizationPercentage=nothing, - ) - - - maxReplicas::Int64 : upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. - - minReplicas::Int64 : minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. - - scaleTargetRef::IoK8sApiAutoscalingV1CrossVersionObjectReference - - targetCPUUtilizationPercentage::Int64 : target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec <: OpenAPI.APIModel - maxReplicas::Union{Nothing, Int64} = nothing - minReplicas::Union{Nothing, Int64} = nothing - scaleTargetRef = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV1CrossVersionObjectReference } - targetCPUUtilizationPercentage::Union{Nothing, Int64} = nothing - - function IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec(maxReplicas, minReplicas, scaleTargetRef, targetCPUUtilizationPercentage, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec, Symbol("maxReplicas"), maxReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec, Symbol("minReplicas"), minReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec, Symbol("scaleTargetRef"), scaleTargetRef) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec, Symbol("targetCPUUtilizationPercentage"), targetCPUUtilizationPercentage) - return new(maxReplicas, minReplicas, scaleTargetRef, targetCPUUtilizationPercentage, ) - end -end # type IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec - -const _property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec = Dict{Symbol,String}(Symbol("maxReplicas")=>"Int64", Symbol("minReplicas")=>"Int64", Symbol("scaleTargetRef")=>"IoK8sApiAutoscalingV1CrossVersionObjectReference", Symbol("targetCPUUtilizationPercentage")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec) - o.maxReplicas === nothing && (return false) - o.scaleTargetRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec }, name::Symbol, val) - if name === Symbol("maxReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec", :format, val, "int32") - end - if name === Symbol("minReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec", :format, val, "int32") - end - if name === Symbol("targetCPUUtilizationPercentage") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus.jl deleted file mode 100644 index 64a096ba..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus.jl +++ /dev/null @@ -1,64 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus -current status of a horizontal pod autoscaler - - IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus(; - currentCPUUtilizationPercentage=nothing, - currentReplicas=nothing, - desiredReplicas=nothing, - lastScaleTime=nothing, - observedGeneration=nothing, - ) - - - currentCPUUtilizationPercentage::Int64 : current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU. - - currentReplicas::Int64 : current number of replicas of pods managed by this autoscaler. - - desiredReplicas::Int64 : desired number of replicas of pods managed by this autoscaler. - - lastScaleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - observedGeneration::Int64 : most recent generation observed by this autoscaler. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus <: OpenAPI.APIModel - currentCPUUtilizationPercentage::Union{Nothing, Int64} = nothing - currentReplicas::Union{Nothing, Int64} = nothing - desiredReplicas::Union{Nothing, Int64} = nothing - lastScaleTime::Union{Nothing, ZonedDateTime} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - - function IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus(currentCPUUtilizationPercentage, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, Symbol("currentCPUUtilizationPercentage"), currentCPUUtilizationPercentage) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, Symbol("desiredReplicas"), desiredReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, Symbol("lastScaleTime"), lastScaleTime) - OpenAPI.validate_property(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, Symbol("observedGeneration"), observedGeneration) - return new(currentCPUUtilizationPercentage, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - end -end # type IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus - -const _property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus = Dict{Symbol,String}(Symbol("currentCPUUtilizationPercentage")=>"Int64", Symbol("currentReplicas")=>"Int64", Symbol("desiredReplicas")=>"Int64", Symbol("lastScaleTime")=>"ZonedDateTime", Symbol("observedGeneration")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus) - o.currentReplicas === nothing && (return false) - o.desiredReplicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus }, name::Symbol, val) - if name === Symbol("currentCPUUtilizationPercentage") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("desiredReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("lastScaleTime") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", :format, val, "date-time") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1Scale.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1Scale.jl deleted file mode 100644 index 4eb5d5fb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1Scale.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.Scale -Scale represents a scaling request for a resource. - - IoK8sApiAutoscalingV1Scale(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAutoscalingV1ScaleSpec - - status::IoK8sApiAutoscalingV1ScaleStatus -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1Scale <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV1ScaleSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV1ScaleStatus } - - function IoK8sApiAutoscalingV1Scale(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1Scale, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV1Scale, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV1Scale, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAutoscalingV1Scale, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAutoscalingV1Scale, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAutoscalingV1Scale - -const _property_types_IoK8sApiAutoscalingV1Scale = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAutoscalingV1ScaleSpec", Symbol("status")=>"IoK8sApiAutoscalingV1ScaleStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1Scale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1Scale[name]))} - -function check_required(o::IoK8sApiAutoscalingV1Scale) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1Scale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleSpec.jl deleted file mode 100644 index e85842aa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleSpec.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.ScaleSpec -ScaleSpec describes the attributes of a scale subresource. - - IoK8sApiAutoscalingV1ScaleSpec(; - replicas=nothing, - ) - - - replicas::Int64 : desired number of instances for the scaled object. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1ScaleSpec <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiAutoscalingV1ScaleSpec(replicas, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1ScaleSpec, Symbol("replicas"), replicas) - return new(replicas, ) - end -end # type IoK8sApiAutoscalingV1ScaleSpec - -const _property_types_IoK8sApiAutoscalingV1ScaleSpec = Dict{Symbol,String}(Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1ScaleSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1ScaleSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV1ScaleSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1ScaleSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1ScaleSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleStatus.jl deleted file mode 100644 index d1e65890..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV1ScaleStatus.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v1.ScaleStatus -ScaleStatus represents the current status of a scale subresource. - - IoK8sApiAutoscalingV1ScaleStatus(; - replicas=nothing, - selector=nothing, - ) - - - replicas::Int64 : actual number of observed instances of the scaled object. - - selector::String : label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV1ScaleStatus <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - selector::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV1ScaleStatus(replicas, selector, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV1ScaleStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV1ScaleStatus, Symbol("selector"), selector) - return new(replicas, selector, ) - end -end # type IoK8sApiAutoscalingV1ScaleStatus - -const _property_types_IoK8sApiAutoscalingV1ScaleStatus = Dict{Symbol,String}(Symbol("replicas")=>"Int64", Symbol("selector")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV1ScaleStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV1ScaleStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV1ScaleStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV1ScaleStatus }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV1ScaleStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference.jl deleted file mode 100644 index a256c790..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference -CrossVersionObjectReference contains enough information to let you identify the referred resource. - - IoK8sApiAutoscalingV2beta1CrossVersionObjectReference(; - apiVersion=nothing, - kind=nothing, - name=nothing, - ) - - - apiVersion::String : API version of the referent - - kind::String : Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\" - - name::String : Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1CrossVersionObjectReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1CrossVersionObjectReference(apiVersion, kind, name, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1CrossVersionObjectReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1CrossVersionObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1CrossVersionObjectReference, Symbol("name"), name) - return new(apiVersion, kind, name, ) - end -end # type IoK8sApiAutoscalingV2beta1CrossVersionObjectReference - -const _property_types_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1CrossVersionObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1CrossVersionObjectReference[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1CrossVersionObjectReference) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1CrossVersionObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricSource.jl deleted file mode 100644 index 57050015..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricSource.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ExternalMetricSource -ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). Exactly one \"target\" type should be set. - - IoK8sApiAutoscalingV2beta1ExternalMetricSource(; - metricName=nothing, - metricSelector=nothing, - targetAverageValue=nothing, - targetValue=nothing, - ) - - - metricName::String : metricName is the name of the metric in question. - - metricSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - targetAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - targetValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ExternalMetricSource <: OpenAPI.APIModel - metricName::Union{Nothing, String} = nothing - metricSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - targetAverageValue::Union{Nothing, String} = nothing - targetValue::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1ExternalMetricSource(metricName, metricSelector, targetAverageValue, targetValue, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricSource, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricSource, Symbol("metricSelector"), metricSelector) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricSource, Symbol("targetAverageValue"), targetAverageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricSource, Symbol("targetValue"), targetValue) - return new(metricName, metricSelector, targetAverageValue, targetValue, ) - end -end # type IoK8sApiAutoscalingV2beta1ExternalMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta1ExternalMetricSource = Dict{Symbol,String}(Symbol("metricName")=>"String", Symbol("metricSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("targetAverageValue")=>"String", Symbol("targetValue")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ExternalMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ExternalMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ExternalMetricSource) - o.metricName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ExternalMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricStatus.jl deleted file mode 100644 index 84ac1c51..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ExternalMetricStatus.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus -ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. - - IoK8sApiAutoscalingV2beta1ExternalMetricStatus(; - currentAverageValue=nothing, - currentValue=nothing, - metricName=nothing, - metricSelector=nothing, - ) - - - currentAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - currentValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - metricName::String : metricName is the name of a metric used for autoscaling in metric system. - - metricSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ExternalMetricStatus <: OpenAPI.APIModel - currentAverageValue::Union{Nothing, String} = nothing - currentValue::Union{Nothing, String} = nothing - metricName::Union{Nothing, String} = nothing - metricSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiAutoscalingV2beta1ExternalMetricStatus(currentAverageValue, currentValue, metricName, metricSelector, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricStatus, Symbol("currentAverageValue"), currentAverageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricStatus, Symbol("currentValue"), currentValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricStatus, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ExternalMetricStatus, Symbol("metricSelector"), metricSelector) - return new(currentAverageValue, currentValue, metricName, metricSelector, ) - end -end # type IoK8sApiAutoscalingV2beta1ExternalMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta1ExternalMetricStatus = Dict{Symbol,String}(Symbol("currentAverageValue")=>"String", Symbol("currentValue")=>"String", Symbol("metricName")=>"String", Symbol("metricSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ExternalMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ExternalMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ExternalMetricStatus) - o.currentValue === nothing && (return false) - o.metricName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ExternalMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler.jl deleted file mode 100644 index 02d55bb2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler -HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. - - IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec - - status::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus } - - function IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler - -const _property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec", Symbol("status")=>"IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition.jl deleted file mode 100644 index 56637a8b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition -HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. - - IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : message is a human-readable explanation containing details about the transition - - reason::String : reason is the reason for the condition's last transition. - - status::String : status is the status of the condition (True, False, Unknown) - - type::String : type describes the current condition -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition - -const _property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList.jl deleted file mode 100644 index 29b054b2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerList -HorizontalPodAutoscaler is a list of horizontal pod autoscaler objects. - - IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler} : items is the list of horizontal pod autoscaler objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList - -const _property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec.jl deleted file mode 100644 index c3dbae29..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec -HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. - - IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec(; - maxReplicas=nothing, - metrics=nothing, - minReplicas=nothing, - scaleTargetRef=nothing, - ) - - - maxReplicas::Int64 : maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. - - metrics::Vector{IoK8sApiAutoscalingV2beta1MetricSpec} : metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. - - minReplicas::Int64 : minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. - - scaleTargetRef::IoK8sApiAutoscalingV2beta1CrossVersionObjectReference -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec <: OpenAPI.APIModel - maxReplicas::Union{Nothing, Int64} = nothing - metrics::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta1MetricSpec} } - minReplicas::Union{Nothing, Int64} = nothing - scaleTargetRef = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1CrossVersionObjectReference } - - function IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec(maxReplicas, metrics, minReplicas, scaleTargetRef, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec, Symbol("maxReplicas"), maxReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec, Symbol("metrics"), metrics) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec, Symbol("minReplicas"), minReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec, Symbol("scaleTargetRef"), scaleTargetRef) - return new(maxReplicas, metrics, minReplicas, scaleTargetRef, ) - end -end # type IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec - -const _property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec = Dict{Symbol,String}(Symbol("maxReplicas")=>"Int64", Symbol("metrics")=>"Vector{IoK8sApiAutoscalingV2beta1MetricSpec}", Symbol("minReplicas")=>"Int64", Symbol("scaleTargetRef")=>"IoK8sApiAutoscalingV2beta1CrossVersionObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec) - o.maxReplicas === nothing && (return false) - o.scaleTargetRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec }, name::Symbol, val) - if name === Symbol("maxReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec", :format, val, "int32") - end - if name === Symbol("minReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus.jl deleted file mode 100644 index d05a0e40..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus -HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. - - IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus(; - conditions=nothing, - currentMetrics=nothing, - currentReplicas=nothing, - desiredReplicas=nothing, - lastScaleTime=nothing, - observedGeneration=nothing, - ) - - - conditions::Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition} : conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. - - currentMetrics::Vector{IoK8sApiAutoscalingV2beta1MetricStatus} : currentMetrics is the last read state of the metrics used by this autoscaler. - - currentReplicas::Int64 : currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler. - - desiredReplicas::Int64 : desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler. - - lastScaleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - observedGeneration::Int64 : observedGeneration is the most recent generation observed by this autoscaler. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition} } - currentMetrics::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta1MetricStatus} } - currentReplicas::Union{Nothing, Int64} = nothing - desiredReplicas::Union{Nothing, Int64} = nothing - lastScaleTime::Union{Nothing, ZonedDateTime} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - - function IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus(conditions, currentMetrics, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("currentMetrics"), currentMetrics) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("desiredReplicas"), desiredReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("lastScaleTime"), lastScaleTime) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus, Symbol("observedGeneration"), observedGeneration) - return new(conditions, currentMetrics, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - end -end # type IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus - -const _property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition}", Symbol("currentMetrics")=>"Vector{IoK8sApiAutoscalingV2beta1MetricStatus}", Symbol("currentReplicas")=>"Int64", Symbol("desiredReplicas")=>"Int64", Symbol("lastScaleTime")=>"ZonedDateTime", Symbol("observedGeneration")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus) - o.conditions === nothing && (return false) - o.currentReplicas === nothing && (return false) - o.desiredReplicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus }, name::Symbol, val) - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("desiredReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("lastScaleTime") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus", :format, val, "date-time") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricSpec.jl deleted file mode 100644 index 90d828bb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricSpec.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.MetricSpec -MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). - - IoK8sApiAutoscalingV2beta1MetricSpec(; - external=nothing, - object=nothing, - pods=nothing, - resource=nothing, - type=nothing, - ) - - - external::IoK8sApiAutoscalingV2beta1ExternalMetricSource - - object::IoK8sApiAutoscalingV2beta1ObjectMetricSource - - pods::IoK8sApiAutoscalingV2beta1PodsMetricSource - - resource::IoK8sApiAutoscalingV2beta1ResourceMetricSource - - type::String : type is the type of metric source. It should be one of \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1MetricSpec <: OpenAPI.APIModel - external = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ExternalMetricSource } - object = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ObjectMetricSource } - pods = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1PodsMetricSource } - resource = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ResourceMetricSource } - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1MetricSpec(external, object, pods, resource, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricSpec, Symbol("external"), external) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricSpec, Symbol("object"), object) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricSpec, Symbol("pods"), pods) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricSpec, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricSpec, Symbol("type"), type) - return new(external, object, pods, resource, type, ) - end -end # type IoK8sApiAutoscalingV2beta1MetricSpec - -const _property_types_IoK8sApiAutoscalingV2beta1MetricSpec = Dict{Symbol,String}(Symbol("external")=>"IoK8sApiAutoscalingV2beta1ExternalMetricSource", Symbol("object")=>"IoK8sApiAutoscalingV2beta1ObjectMetricSource", Symbol("pods")=>"IoK8sApiAutoscalingV2beta1PodsMetricSource", Symbol("resource")=>"IoK8sApiAutoscalingV2beta1ResourceMetricSource", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1MetricSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1MetricSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1MetricSpec) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1MetricSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricStatus.jl deleted file mode 100644 index ad376465..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1MetricStatus.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.MetricStatus -MetricStatus describes the last-read state of a single metric. - - IoK8sApiAutoscalingV2beta1MetricStatus(; - external=nothing, - object=nothing, - pods=nothing, - resource=nothing, - type=nothing, - ) - - - external::IoK8sApiAutoscalingV2beta1ExternalMetricStatus - - object::IoK8sApiAutoscalingV2beta1ObjectMetricStatus - - pods::IoK8sApiAutoscalingV2beta1PodsMetricStatus - - resource::IoK8sApiAutoscalingV2beta1ResourceMetricStatus - - type::String : type is the type of metric source. It will be one of \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1MetricStatus <: OpenAPI.APIModel - external = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ExternalMetricStatus } - object = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ObjectMetricStatus } - pods = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1PodsMetricStatus } - resource = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1ResourceMetricStatus } - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1MetricStatus(external, object, pods, resource, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricStatus, Symbol("external"), external) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricStatus, Symbol("object"), object) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricStatus, Symbol("pods"), pods) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricStatus, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1MetricStatus, Symbol("type"), type) - return new(external, object, pods, resource, type, ) - end -end # type IoK8sApiAutoscalingV2beta1MetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta1MetricStatus = Dict{Symbol,String}(Symbol("external")=>"IoK8sApiAutoscalingV2beta1ExternalMetricStatus", Symbol("object")=>"IoK8sApiAutoscalingV2beta1ObjectMetricStatus", Symbol("pods")=>"IoK8sApiAutoscalingV2beta1PodsMetricStatus", Symbol("resource")=>"IoK8sApiAutoscalingV2beta1ResourceMetricStatus", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1MetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1MetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1MetricStatus) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1MetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricSource.jl deleted file mode 100644 index fdbcda75..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricSource.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ObjectMetricSource -ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). - - IoK8sApiAutoscalingV2beta1ObjectMetricSource(; - averageValue=nothing, - metricName=nothing, - selector=nothing, - target=nothing, - targetValue=nothing, - ) - - - averageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - metricName::String : metricName is the name of the metric in question. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - target::IoK8sApiAutoscalingV2beta1CrossVersionObjectReference - - targetValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ObjectMetricSource <: OpenAPI.APIModel - averageValue::Union{Nothing, String} = nothing - metricName::Union{Nothing, String} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1CrossVersionObjectReference } - targetValue::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1ObjectMetricSource(averageValue, metricName, selector, target, targetValue, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricSource, Symbol("averageValue"), averageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricSource, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricSource, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricSource, Symbol("target"), target) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricSource, Symbol("targetValue"), targetValue) - return new(averageValue, metricName, selector, target, targetValue, ) - end -end # type IoK8sApiAutoscalingV2beta1ObjectMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta1ObjectMetricSource = Dict{Symbol,String}(Symbol("averageValue")=>"String", Symbol("metricName")=>"String", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("target")=>"IoK8sApiAutoscalingV2beta1CrossVersionObjectReference", Symbol("targetValue")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ObjectMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ObjectMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ObjectMetricSource) - o.metricName === nothing && (return false) - o.target === nothing && (return false) - o.targetValue === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ObjectMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricStatus.jl deleted file mode 100644 index db57ed4c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ObjectMetricStatus.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus -ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). - - IoK8sApiAutoscalingV2beta1ObjectMetricStatus(; - averageValue=nothing, - currentValue=nothing, - metricName=nothing, - selector=nothing, - target=nothing, - ) - - - averageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - currentValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - metricName::String : metricName is the name of the metric in question. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - target::IoK8sApiAutoscalingV2beta1CrossVersionObjectReference -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ObjectMetricStatus <: OpenAPI.APIModel - averageValue::Union{Nothing, String} = nothing - currentValue::Union{Nothing, String} = nothing - metricName::Union{Nothing, String} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta1CrossVersionObjectReference } - - function IoK8sApiAutoscalingV2beta1ObjectMetricStatus(averageValue, currentValue, metricName, selector, target, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricStatus, Symbol("averageValue"), averageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricStatus, Symbol("currentValue"), currentValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricStatus, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricStatus, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ObjectMetricStatus, Symbol("target"), target) - return new(averageValue, currentValue, metricName, selector, target, ) - end -end # type IoK8sApiAutoscalingV2beta1ObjectMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta1ObjectMetricStatus = Dict{Symbol,String}(Symbol("averageValue")=>"String", Symbol("currentValue")=>"String", Symbol("metricName")=>"String", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("target")=>"IoK8sApiAutoscalingV2beta1CrossVersionObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ObjectMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ObjectMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ObjectMetricStatus) - o.currentValue === nothing && (return false) - o.metricName === nothing && (return false) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ObjectMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricSource.jl deleted file mode 100644 index 50743b3a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricSource.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.PodsMetricSource -PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. - - IoK8sApiAutoscalingV2beta1PodsMetricSource(; - metricName=nothing, - selector=nothing, - targetAverageValue=nothing, - ) - - - metricName::String : metricName is the name of the metric in question - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - targetAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1PodsMetricSource <: OpenAPI.APIModel - metricName::Union{Nothing, String} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - targetAverageValue::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1PodsMetricSource(metricName, selector, targetAverageValue, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricSource, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricSource, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricSource, Symbol("targetAverageValue"), targetAverageValue) - return new(metricName, selector, targetAverageValue, ) - end -end # type IoK8sApiAutoscalingV2beta1PodsMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta1PodsMetricSource = Dict{Symbol,String}(Symbol("metricName")=>"String", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("targetAverageValue")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1PodsMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1PodsMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1PodsMetricSource) - o.metricName === nothing && (return false) - o.targetAverageValue === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1PodsMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricStatus.jl deleted file mode 100644 index a48988ce..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1PodsMetricStatus.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.PodsMetricStatus -PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). - - IoK8sApiAutoscalingV2beta1PodsMetricStatus(; - currentAverageValue=nothing, - metricName=nothing, - selector=nothing, - ) - - - currentAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - metricName::String : metricName is the name of the metric in question - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1PodsMetricStatus <: OpenAPI.APIModel - currentAverageValue::Union{Nothing, String} = nothing - metricName::Union{Nothing, String} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiAutoscalingV2beta1PodsMetricStatus(currentAverageValue, metricName, selector, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricStatus, Symbol("currentAverageValue"), currentAverageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricStatus, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1PodsMetricStatus, Symbol("selector"), selector) - return new(currentAverageValue, metricName, selector, ) - end -end # type IoK8sApiAutoscalingV2beta1PodsMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta1PodsMetricStatus = Dict{Symbol,String}(Symbol("currentAverageValue")=>"String", Symbol("metricName")=>"String", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1PodsMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1PodsMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1PodsMetricStatus) - o.currentAverageValue === nothing && (return false) - o.metricName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1PodsMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricSource.jl deleted file mode 100644 index b51c95d9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricSource.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ResourceMetricSource -ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set. - - IoK8sApiAutoscalingV2beta1ResourceMetricSource(; - name=nothing, - targetAverageUtilization=nothing, - targetAverageValue=nothing, - ) - - - name::String : name is the name of the resource in question. - - targetAverageUtilization::Int64 : targetAverageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. - - targetAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ResourceMetricSource <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - targetAverageUtilization::Union{Nothing, Int64} = nothing - targetAverageValue::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1ResourceMetricSource(name, targetAverageUtilization, targetAverageValue, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricSource, Symbol("targetAverageUtilization"), targetAverageUtilization) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricSource, Symbol("targetAverageValue"), targetAverageValue) - return new(name, targetAverageUtilization, targetAverageValue, ) - end -end # type IoK8sApiAutoscalingV2beta1ResourceMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta1ResourceMetricSource = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("targetAverageUtilization")=>"Int64", Symbol("targetAverageValue")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ResourceMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ResourceMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ResourceMetricSource) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ResourceMetricSource }, name::Symbol, val) - if name === Symbol("targetAverageUtilization") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1ResourceMetricSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricStatus.jl deleted file mode 100644 index b3b1e19e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta1ResourceMetricStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus -ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. - - IoK8sApiAutoscalingV2beta1ResourceMetricStatus(; - currentAverageUtilization=nothing, - currentAverageValue=nothing, - name=nothing, - ) - - - currentAverageUtilization::Int64 : currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. It will only be present if `targetAverageValue` was set in the corresponding metric specification. - - currentAverageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - name::String : name is the name of the resource in question. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta1ResourceMetricStatus <: OpenAPI.APIModel - currentAverageUtilization::Union{Nothing, Int64} = nothing - currentAverageValue::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta1ResourceMetricStatus(currentAverageUtilization, currentAverageValue, name, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricStatus, Symbol("currentAverageUtilization"), currentAverageUtilization) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricStatus, Symbol("currentAverageValue"), currentAverageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta1ResourceMetricStatus, Symbol("name"), name) - return new(currentAverageUtilization, currentAverageValue, name, ) - end -end # type IoK8sApiAutoscalingV2beta1ResourceMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta1ResourceMetricStatus = Dict{Symbol,String}(Symbol("currentAverageUtilization")=>"Int64", Symbol("currentAverageValue")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta1ResourceMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta1ResourceMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta1ResourceMetricStatus) - o.currentAverageValue === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta1ResourceMetricStatus }, name::Symbol, val) - if name === Symbol("currentAverageUtilization") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta1ResourceMetricStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference.jl deleted file mode 100644 index 46cbe5a4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference -CrossVersionObjectReference contains enough information to let you identify the referred resource. - - IoK8sApiAutoscalingV2beta2CrossVersionObjectReference(; - apiVersion=nothing, - kind=nothing, - name=nothing, - ) - - - apiVersion::String : API version of the referent - - kind::String : Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\" - - name::String : Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2CrossVersionObjectReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2CrossVersionObjectReference(apiVersion, kind, name, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2CrossVersionObjectReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2CrossVersionObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2CrossVersionObjectReference, Symbol("name"), name) - return new(apiVersion, kind, name, ) - end -end # type IoK8sApiAutoscalingV2beta2CrossVersionObjectReference - -const _property_types_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2CrossVersionObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2CrossVersionObjectReference[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2CrossVersionObjectReference) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2CrossVersionObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricSource.jl deleted file mode 100644 index f470875a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricSource.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ExternalMetricSource -ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). - - IoK8sApiAutoscalingV2beta2ExternalMetricSource(; - metric=nothing, - target=nothing, - ) - - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier - - target::IoK8sApiAutoscalingV2beta2MetricTarget -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ExternalMetricSource <: OpenAPI.APIModel - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricTarget } - - function IoK8sApiAutoscalingV2beta2ExternalMetricSource(metric, target, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ExternalMetricSource, Symbol("metric"), metric) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ExternalMetricSource, Symbol("target"), target) - return new(metric, target, ) - end -end # type IoK8sApiAutoscalingV2beta2ExternalMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta2ExternalMetricSource = Dict{Symbol,String}(Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", Symbol("target")=>"IoK8sApiAutoscalingV2beta2MetricTarget", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ExternalMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ExternalMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ExternalMetricSource) - o.metric === nothing && (return false) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ExternalMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricStatus.jl deleted file mode 100644 index 22f4f3da..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ExternalMetricStatus.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus -ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. - - IoK8sApiAutoscalingV2beta2ExternalMetricStatus(; - current=nothing, - metric=nothing, - ) - - - current::IoK8sApiAutoscalingV2beta2MetricValueStatus - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ExternalMetricStatus <: OpenAPI.APIModel - current = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricValueStatus } - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - - function IoK8sApiAutoscalingV2beta2ExternalMetricStatus(current, metric, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ExternalMetricStatus, Symbol("current"), current) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ExternalMetricStatus, Symbol("metric"), metric) - return new(current, metric, ) - end -end # type IoK8sApiAutoscalingV2beta2ExternalMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta2ExternalMetricStatus = Dict{Symbol,String}(Symbol("current")=>"IoK8sApiAutoscalingV2beta2MetricValueStatus", Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ExternalMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ExternalMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ExternalMetricStatus) - o.current === nothing && (return false) - o.metric === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ExternalMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler.jl deleted file mode 100644 index 23a92cca..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler -HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. - - IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec - - status::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus } - - function IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler - -const _property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec", Symbol("status")=>"IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition.jl deleted file mode 100644 index 28f24789..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition -HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. - - IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : message is a human-readable explanation containing details about the transition - - reason::String : reason is the reason for the condition's last transition. - - status::String : status is the status of the condition (True, False, Unknown) - - type::String : type describes the current condition -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition - -const _property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList.jl deleted file mode 100644 index a884fc80..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerList -HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. - - IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler} : items is the list of horizontal pod autoscaler objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList - -const _property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec.jl deleted file mode 100644 index 4162cf0f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec -HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. - - IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec(; - maxReplicas=nothing, - metrics=nothing, - minReplicas=nothing, - scaleTargetRef=nothing, - ) - - - maxReplicas::Int64 : maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. - - metrics::Vector{IoK8sApiAutoscalingV2beta2MetricSpec} : metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization. - - minReplicas::Int64 : minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. - - scaleTargetRef::IoK8sApiAutoscalingV2beta2CrossVersionObjectReference -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec <: OpenAPI.APIModel - maxReplicas::Union{Nothing, Int64} = nothing - metrics::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta2MetricSpec} } - minReplicas::Union{Nothing, Int64} = nothing - scaleTargetRef = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2CrossVersionObjectReference } - - function IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec(maxReplicas, metrics, minReplicas, scaleTargetRef, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec, Symbol("maxReplicas"), maxReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec, Symbol("metrics"), metrics) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec, Symbol("minReplicas"), minReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec, Symbol("scaleTargetRef"), scaleTargetRef) - return new(maxReplicas, metrics, minReplicas, scaleTargetRef, ) - end -end # type IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec - -const _property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec = Dict{Symbol,String}(Symbol("maxReplicas")=>"Int64", Symbol("metrics")=>"Vector{IoK8sApiAutoscalingV2beta2MetricSpec}", Symbol("minReplicas")=>"Int64", Symbol("scaleTargetRef")=>"IoK8sApiAutoscalingV2beta2CrossVersionObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec) - o.maxReplicas === nothing && (return false) - o.scaleTargetRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec }, name::Symbol, val) - if name === Symbol("maxReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec", :format, val, "int32") - end - if name === Symbol("minReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus.jl deleted file mode 100644 index 7c52bf0a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus -HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. - - IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus(; - conditions=nothing, - currentMetrics=nothing, - currentReplicas=nothing, - desiredReplicas=nothing, - lastScaleTime=nothing, - observedGeneration=nothing, - ) - - - conditions::Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition} : conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. - - currentMetrics::Vector{IoK8sApiAutoscalingV2beta2MetricStatus} : currentMetrics is the last read state of the metrics used by this autoscaler. - - currentReplicas::Int64 : currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler. - - desiredReplicas::Int64 : desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler. - - lastScaleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - observedGeneration::Int64 : observedGeneration is the most recent generation observed by this autoscaler. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition} } - currentMetrics::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiAutoscalingV2beta2MetricStatus} } - currentReplicas::Union{Nothing, Int64} = nothing - desiredReplicas::Union{Nothing, Int64} = nothing - lastScaleTime::Union{Nothing, ZonedDateTime} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - - function IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus(conditions, currentMetrics, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("currentMetrics"), currentMetrics) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("currentReplicas"), currentReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("desiredReplicas"), desiredReplicas) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("lastScaleTime"), lastScaleTime) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus, Symbol("observedGeneration"), observedGeneration) - return new(conditions, currentMetrics, currentReplicas, desiredReplicas, lastScaleTime, observedGeneration, ) - end -end # type IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus - -const _property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition}", Symbol("currentMetrics")=>"Vector{IoK8sApiAutoscalingV2beta2MetricStatus}", Symbol("currentReplicas")=>"Int64", Symbol("desiredReplicas")=>"Int64", Symbol("lastScaleTime")=>"ZonedDateTime", Symbol("observedGeneration")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus) - o.conditions === nothing && (return false) - o.currentReplicas === nothing && (return false) - o.desiredReplicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus }, name::Symbol, val) - if name === Symbol("currentReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("desiredReplicas") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus", :format, val, "int32") - end - if name === Symbol("lastScaleTime") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus", :format, val, "date-time") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricIdentifier.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricIdentifier.jl deleted file mode 100644 index 44d9d348..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricIdentifier.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.MetricIdentifier -MetricIdentifier defines the name and optionally selector for a metric - - IoK8sApiAutoscalingV2beta2MetricIdentifier(; - name=nothing, - selector=nothing, - ) - - - name::String : name is the name of the given metric - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2MetricIdentifier <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiAutoscalingV2beta2MetricIdentifier(name, selector, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricIdentifier, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricIdentifier, Symbol("selector"), selector) - return new(name, selector, ) - end -end # type IoK8sApiAutoscalingV2beta2MetricIdentifier - -const _property_types_IoK8sApiAutoscalingV2beta2MetricIdentifier = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2MetricIdentifier }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2MetricIdentifier[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2MetricIdentifier) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2MetricIdentifier }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricSpec.jl deleted file mode 100644 index a8e9fb55..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricSpec.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.MetricSpec -MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). - - IoK8sApiAutoscalingV2beta2MetricSpec(; - external=nothing, - object=nothing, - pods=nothing, - resource=nothing, - type=nothing, - ) - - - external::IoK8sApiAutoscalingV2beta2ExternalMetricSource - - object::IoK8sApiAutoscalingV2beta2ObjectMetricSource - - pods::IoK8sApiAutoscalingV2beta2PodsMetricSource - - resource::IoK8sApiAutoscalingV2beta2ResourceMetricSource - - type::String : type is the type of metric source. It should be one of \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2MetricSpec <: OpenAPI.APIModel - external = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ExternalMetricSource } - object = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ObjectMetricSource } - pods = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2PodsMetricSource } - resource = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ResourceMetricSource } - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2MetricSpec(external, object, pods, resource, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricSpec, Symbol("external"), external) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricSpec, Symbol("object"), object) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricSpec, Symbol("pods"), pods) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricSpec, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricSpec, Symbol("type"), type) - return new(external, object, pods, resource, type, ) - end -end # type IoK8sApiAutoscalingV2beta2MetricSpec - -const _property_types_IoK8sApiAutoscalingV2beta2MetricSpec = Dict{Symbol,String}(Symbol("external")=>"IoK8sApiAutoscalingV2beta2ExternalMetricSource", Symbol("object")=>"IoK8sApiAutoscalingV2beta2ObjectMetricSource", Symbol("pods")=>"IoK8sApiAutoscalingV2beta2PodsMetricSource", Symbol("resource")=>"IoK8sApiAutoscalingV2beta2ResourceMetricSource", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2MetricSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2MetricSpec[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2MetricSpec) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2MetricSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricStatus.jl deleted file mode 100644 index ed8ed223..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricStatus.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.MetricStatus -MetricStatus describes the last-read state of a single metric. - - IoK8sApiAutoscalingV2beta2MetricStatus(; - external=nothing, - object=nothing, - pods=nothing, - resource=nothing, - type=nothing, - ) - - - external::IoK8sApiAutoscalingV2beta2ExternalMetricStatus - - object::IoK8sApiAutoscalingV2beta2ObjectMetricStatus - - pods::IoK8sApiAutoscalingV2beta2PodsMetricStatus - - resource::IoK8sApiAutoscalingV2beta2ResourceMetricStatus - - type::String : type is the type of metric source. It will be one of \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2MetricStatus <: OpenAPI.APIModel - external = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ExternalMetricStatus } - object = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ObjectMetricStatus } - pods = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2PodsMetricStatus } - resource = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2ResourceMetricStatus } - type::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2MetricStatus(external, object, pods, resource, type, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricStatus, Symbol("external"), external) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricStatus, Symbol("object"), object) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricStatus, Symbol("pods"), pods) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricStatus, Symbol("resource"), resource) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricStatus, Symbol("type"), type) - return new(external, object, pods, resource, type, ) - end -end # type IoK8sApiAutoscalingV2beta2MetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta2MetricStatus = Dict{Symbol,String}(Symbol("external")=>"IoK8sApiAutoscalingV2beta2ExternalMetricStatus", Symbol("object")=>"IoK8sApiAutoscalingV2beta2ObjectMetricStatus", Symbol("pods")=>"IoK8sApiAutoscalingV2beta2PodsMetricStatus", Symbol("resource")=>"IoK8sApiAutoscalingV2beta2ResourceMetricStatus", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2MetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2MetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2MetricStatus) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2MetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricTarget.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricTarget.jl deleted file mode 100644 index 9d5fa669..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricTarget.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.MetricTarget -MetricTarget defines the target value, average value, or average utilization of a specific metric - - IoK8sApiAutoscalingV2beta2MetricTarget(; - averageUtilization=nothing, - averageValue=nothing, - type=nothing, - value=nothing, - ) - - - averageUtilization::Int64 : averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type - - averageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - type::String : type represents whether the metric type is Utilization, Value, or AverageValue - - value::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2MetricTarget <: OpenAPI.APIModel - averageUtilization::Union{Nothing, Int64} = nothing - averageValue::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2MetricTarget(averageUtilization, averageValue, type, value, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricTarget, Symbol("averageUtilization"), averageUtilization) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricTarget, Symbol("averageValue"), averageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricTarget, Symbol("type"), type) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricTarget, Symbol("value"), value) - return new(averageUtilization, averageValue, type, value, ) - end -end # type IoK8sApiAutoscalingV2beta2MetricTarget - -const _property_types_IoK8sApiAutoscalingV2beta2MetricTarget = Dict{Symbol,String}(Symbol("averageUtilization")=>"Int64", Symbol("averageValue")=>"String", Symbol("type")=>"String", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2MetricTarget }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2MetricTarget[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2MetricTarget) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2MetricTarget }, name::Symbol, val) - if name === Symbol("averageUtilization") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2MetricTarget", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricValueStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricValueStatus.jl deleted file mode 100644 index 595ce3a1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2MetricValueStatus.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.MetricValueStatus -MetricValueStatus holds the current value for a metric - - IoK8sApiAutoscalingV2beta2MetricValueStatus(; - averageUtilization=nothing, - averageValue=nothing, - value=nothing, - ) - - - averageUtilization::Int64 : currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. - - averageValue::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - value::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2MetricValueStatus <: OpenAPI.APIModel - averageUtilization::Union{Nothing, Int64} = nothing - averageValue::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2MetricValueStatus(averageUtilization, averageValue, value, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricValueStatus, Symbol("averageUtilization"), averageUtilization) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricValueStatus, Symbol("averageValue"), averageValue) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2MetricValueStatus, Symbol("value"), value) - return new(averageUtilization, averageValue, value, ) - end -end # type IoK8sApiAutoscalingV2beta2MetricValueStatus - -const _property_types_IoK8sApiAutoscalingV2beta2MetricValueStatus = Dict{Symbol,String}(Symbol("averageUtilization")=>"Int64", Symbol("averageValue")=>"String", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2MetricValueStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2MetricValueStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2MetricValueStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2MetricValueStatus }, name::Symbol, val) - if name === Symbol("averageUtilization") - OpenAPI.validate_param(name, "IoK8sApiAutoscalingV2beta2MetricValueStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricSource.jl deleted file mode 100644 index b9b3e4bf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricSource.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ObjectMetricSource -ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). - - IoK8sApiAutoscalingV2beta2ObjectMetricSource(; - describedObject=nothing, - metric=nothing, - target=nothing, - ) - - - describedObject::IoK8sApiAutoscalingV2beta2CrossVersionObjectReference - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier - - target::IoK8sApiAutoscalingV2beta2MetricTarget -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ObjectMetricSource <: OpenAPI.APIModel - describedObject = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2CrossVersionObjectReference } - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricTarget } - - function IoK8sApiAutoscalingV2beta2ObjectMetricSource(describedObject, metric, target, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricSource, Symbol("describedObject"), describedObject) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricSource, Symbol("metric"), metric) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricSource, Symbol("target"), target) - return new(describedObject, metric, target, ) - end -end # type IoK8sApiAutoscalingV2beta2ObjectMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta2ObjectMetricSource = Dict{Symbol,String}(Symbol("describedObject")=>"IoK8sApiAutoscalingV2beta2CrossVersionObjectReference", Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", Symbol("target")=>"IoK8sApiAutoscalingV2beta2MetricTarget", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ObjectMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ObjectMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ObjectMetricSource) - o.describedObject === nothing && (return false) - o.metric === nothing && (return false) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ObjectMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricStatus.jl deleted file mode 100644 index 7e14ae66..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ObjectMetricStatus.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus -ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). - - IoK8sApiAutoscalingV2beta2ObjectMetricStatus(; - current=nothing, - describedObject=nothing, - metric=nothing, - ) - - - current::IoK8sApiAutoscalingV2beta2MetricValueStatus - - describedObject::IoK8sApiAutoscalingV2beta2CrossVersionObjectReference - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ObjectMetricStatus <: OpenAPI.APIModel - current = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricValueStatus } - describedObject = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2CrossVersionObjectReference } - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - - function IoK8sApiAutoscalingV2beta2ObjectMetricStatus(current, describedObject, metric, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricStatus, Symbol("current"), current) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricStatus, Symbol("describedObject"), describedObject) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ObjectMetricStatus, Symbol("metric"), metric) - return new(current, describedObject, metric, ) - end -end # type IoK8sApiAutoscalingV2beta2ObjectMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta2ObjectMetricStatus = Dict{Symbol,String}(Symbol("current")=>"IoK8sApiAutoscalingV2beta2MetricValueStatus", Symbol("describedObject")=>"IoK8sApiAutoscalingV2beta2CrossVersionObjectReference", Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ObjectMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ObjectMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ObjectMetricStatus) - o.current === nothing && (return false) - o.describedObject === nothing && (return false) - o.metric === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ObjectMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricSource.jl deleted file mode 100644 index 931de94a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricSource.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.PodsMetricSource -PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. - - IoK8sApiAutoscalingV2beta2PodsMetricSource(; - metric=nothing, - target=nothing, - ) - - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier - - target::IoK8sApiAutoscalingV2beta2MetricTarget -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2PodsMetricSource <: OpenAPI.APIModel - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricTarget } - - function IoK8sApiAutoscalingV2beta2PodsMetricSource(metric, target, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2PodsMetricSource, Symbol("metric"), metric) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2PodsMetricSource, Symbol("target"), target) - return new(metric, target, ) - end -end # type IoK8sApiAutoscalingV2beta2PodsMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta2PodsMetricSource = Dict{Symbol,String}(Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", Symbol("target")=>"IoK8sApiAutoscalingV2beta2MetricTarget", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2PodsMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2PodsMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2PodsMetricSource) - o.metric === nothing && (return false) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2PodsMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricStatus.jl deleted file mode 100644 index a2324b14..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2PodsMetricStatus.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.PodsMetricStatus -PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). - - IoK8sApiAutoscalingV2beta2PodsMetricStatus(; - current=nothing, - metric=nothing, - ) - - - current::IoK8sApiAutoscalingV2beta2MetricValueStatus - - metric::IoK8sApiAutoscalingV2beta2MetricIdentifier -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2PodsMetricStatus <: OpenAPI.APIModel - current = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricValueStatus } - metric = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricIdentifier } - - function IoK8sApiAutoscalingV2beta2PodsMetricStatus(current, metric, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2PodsMetricStatus, Symbol("current"), current) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2PodsMetricStatus, Symbol("metric"), metric) - return new(current, metric, ) - end -end # type IoK8sApiAutoscalingV2beta2PodsMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta2PodsMetricStatus = Dict{Symbol,String}(Symbol("current")=>"IoK8sApiAutoscalingV2beta2MetricValueStatus", Symbol("metric")=>"IoK8sApiAutoscalingV2beta2MetricIdentifier", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2PodsMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2PodsMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2PodsMetricStatus) - o.current === nothing && (return false) - o.metric === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2PodsMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricSource.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricSource.jl deleted file mode 100644 index 6298c8dd..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricSource.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ResourceMetricSource -ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set. - - IoK8sApiAutoscalingV2beta2ResourceMetricSource(; - name=nothing, - target=nothing, - ) - - - name::String : name is the name of the resource in question. - - target::IoK8sApiAutoscalingV2beta2MetricTarget -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ResourceMetricSource <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - target = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricTarget } - - function IoK8sApiAutoscalingV2beta2ResourceMetricSource(name, target, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ResourceMetricSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ResourceMetricSource, Symbol("target"), target) - return new(name, target, ) - end -end # type IoK8sApiAutoscalingV2beta2ResourceMetricSource - -const _property_types_IoK8sApiAutoscalingV2beta2ResourceMetricSource = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("target")=>"IoK8sApiAutoscalingV2beta2MetricTarget", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ResourceMetricSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ResourceMetricSource[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ResourceMetricSource) - o.name === nothing && (return false) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ResourceMetricSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricStatus.jl deleted file mode 100644 index 5679e7fc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiAutoscalingV2beta2ResourceMetricStatus.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus -ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. - - IoK8sApiAutoscalingV2beta2ResourceMetricStatus(; - current=nothing, - name=nothing, - ) - - - current::IoK8sApiAutoscalingV2beta2MetricValueStatus - - name::String : Name is the name of the resource in question. -""" -Base.@kwdef mutable struct IoK8sApiAutoscalingV2beta2ResourceMetricStatus <: OpenAPI.APIModel - current = nothing # spec type: Union{ Nothing, IoK8sApiAutoscalingV2beta2MetricValueStatus } - name::Union{Nothing, String} = nothing - - function IoK8sApiAutoscalingV2beta2ResourceMetricStatus(current, name, ) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ResourceMetricStatus, Symbol("current"), current) - OpenAPI.validate_property(IoK8sApiAutoscalingV2beta2ResourceMetricStatus, Symbol("name"), name) - return new(current, name, ) - end -end # type IoK8sApiAutoscalingV2beta2ResourceMetricStatus - -const _property_types_IoK8sApiAutoscalingV2beta2ResourceMetricStatus = Dict{Symbol,String}(Symbol("current")=>"IoK8sApiAutoscalingV2beta2MetricValueStatus", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiAutoscalingV2beta2ResourceMetricStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiAutoscalingV2beta2ResourceMetricStatus[name]))} - -function check_required(o::IoK8sApiAutoscalingV2beta2ResourceMetricStatus) - o.current === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiAutoscalingV2beta2ResourceMetricStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJob.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJob.jl deleted file mode 100644 index 6157ed8d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJob.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.CronJob -CronJob represents the configuration of a single cron job. - - IoK8sApiBatchV1CronJob(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1CronJobSpec - - status::IoK8sApiBatchV1CronJobStatus -""" -Base.@kwdef mutable struct IoK8sApiBatchV1CronJob <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1CronJobSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1CronJobStatus } - - function IoK8sApiBatchV1CronJob(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiBatchV1CronJob, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1CronJob, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1CronJob, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV1CronJob, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiBatchV1CronJob, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiBatchV1CronJob - -const _property_types_IoK8sApiBatchV1CronJob = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1CronJobSpec", Symbol("status")=>"IoK8sApiBatchV1CronJobStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1CronJob }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1CronJob[name]))} - -function check_required(o::IoK8sApiBatchV1CronJob) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1CronJob }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobList.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobList.jl deleted file mode 100644 index a5e3a98e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.CronJobList -CronJobList is a collection of cron jobs. - - IoK8sApiBatchV1CronJobList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiBatchV1CronJob} : items is the list of CronJobs. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiBatchV1CronJobList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiBatchV1CronJob} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiBatchV1CronJobList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiBatchV1CronJobList - -const _property_types_IoK8sApiBatchV1CronJobList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiBatchV1CronJob}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1CronJobList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1CronJobList[name]))} - -function check_required(o::IoK8sApiBatchV1CronJobList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1CronJobList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobSpec.jl deleted file mode 100644 index 1649d39e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobSpec.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.CronJobSpec -CronJobSpec describes how the job execution will look like and when it will actually run. - - IoK8sApiBatchV1CronJobSpec(; - concurrencyPolicy=nothing, - failedJobsHistoryLimit=nothing, - jobTemplate=nothing, - schedule=nothing, - startingDeadlineSeconds=nothing, - successfulJobsHistoryLimit=nothing, - suspend=nothing, - ) - - - concurrencyPolicy::String : Specifies how to treat concurrent executions of a Job. Valid values are: - \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \"Replace\": cancels currently running job and replaces it with a new one - - failedJobsHistoryLimit::Int64 : The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1. - - jobTemplate::IoK8sApiBatchV1JobTemplateSpec - - schedule::String : The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. - - startingDeadlineSeconds::Int64 : Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. - - successfulJobsHistoryLimit::Int64 : The number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3. - - suspend::Bool : This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1CronJobSpec <: OpenAPI.APIModel - concurrencyPolicy::Union{Nothing, String} = nothing - failedJobsHistoryLimit::Union{Nothing, Int64} = nothing - jobTemplate = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobTemplateSpec } - schedule::Union{Nothing, String} = nothing - startingDeadlineSeconds::Union{Nothing, Int64} = nothing - successfulJobsHistoryLimit::Union{Nothing, Int64} = nothing - suspend::Union{Nothing, Bool} = nothing - - function IoK8sApiBatchV1CronJobSpec(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("concurrencyPolicy"), concurrencyPolicy) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("failedJobsHistoryLimit"), failedJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("jobTemplate"), jobTemplate) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("schedule"), schedule) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("startingDeadlineSeconds"), startingDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("successfulJobsHistoryLimit"), successfulJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobSpec, Symbol("suspend"), suspend) - return new(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - end -end # type IoK8sApiBatchV1CronJobSpec - -const _property_types_IoK8sApiBatchV1CronJobSpec = Dict{Symbol,String}(Symbol("concurrencyPolicy")=>"String", Symbol("failedJobsHistoryLimit")=>"Int64", Symbol("jobTemplate")=>"IoK8sApiBatchV1JobTemplateSpec", Symbol("schedule")=>"String", Symbol("startingDeadlineSeconds")=>"Int64", Symbol("successfulJobsHistoryLimit")=>"Int64", Symbol("suspend")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1CronJobSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1CronJobSpec[name]))} - -function check_required(o::IoK8sApiBatchV1CronJobSpec) - o.jobTemplate === nothing && (return false) - o.schedule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1CronJobSpec }, name::Symbol, val) - if name === Symbol("failedJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV1CronJobSpec", :format, val, "int32") - end - if name === Symbol("startingDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiBatchV1CronJobSpec", :format, val, "int64") - end - if name === Symbol("successfulJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV1CronJobSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobStatus.jl deleted file mode 100644 index fb703785..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1CronJobStatus.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.CronJobStatus -CronJobStatus represents the current state of a cron job. - - IoK8sApiBatchV1CronJobStatus(; - active=nothing, - lastScheduleTime=nothing, - lastSuccessfulTime=nothing, - ) - - - active::Vector{IoK8sApiCoreV1ObjectReference} : A list of pointers to currently running jobs. - - lastScheduleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastSuccessfulTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1CronJobStatus <: OpenAPI.APIModel - active::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ObjectReference} } - lastScheduleTime::Union{Nothing, ZonedDateTime} = nothing - lastSuccessfulTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiBatchV1CronJobStatus(active, lastScheduleTime, lastSuccessfulTime, ) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobStatus, Symbol("active"), active) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobStatus, Symbol("lastScheduleTime"), lastScheduleTime) - OpenAPI.validate_property(IoK8sApiBatchV1CronJobStatus, Symbol("lastSuccessfulTime"), lastSuccessfulTime) - return new(active, lastScheduleTime, lastSuccessfulTime, ) - end -end # type IoK8sApiBatchV1CronJobStatus - -const _property_types_IoK8sApiBatchV1CronJobStatus = Dict{Symbol,String}(Symbol("active")=>"Vector{IoK8sApiCoreV1ObjectReference}", Symbol("lastScheduleTime")=>"ZonedDateTime", Symbol("lastSuccessfulTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1CronJobStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1CronJobStatus[name]))} - -function check_required(o::IoK8sApiBatchV1CronJobStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1CronJobStatus }, name::Symbol, val) - if name === Symbol("lastScheduleTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1CronJobStatus", :format, val, "date-time") - end - if name === Symbol("lastSuccessfulTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1CronJobStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1Job.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1Job.jl deleted file mode 100644 index 783935c7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1Job.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.Job -Job represents the configuration of a single job. - - IoK8sApiBatchV1Job(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1JobSpec - - status::IoK8sApiBatchV1JobStatus -""" -Base.@kwdef mutable struct IoK8sApiBatchV1Job <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobStatus } - - function IoK8sApiBatchV1Job(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiBatchV1Job, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1Job, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1Job, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV1Job, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiBatchV1Job, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiBatchV1Job - -const _property_types_IoK8sApiBatchV1Job = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1JobSpec", Symbol("status")=>"IoK8sApiBatchV1JobStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1Job }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1Job[name]))} - -function check_required(o::IoK8sApiBatchV1Job) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1Job }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobCondition.jl deleted file mode 100644 index 97728e44..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.JobCondition -JobCondition describes current state of a job. - - IoK8sApiBatchV1JobCondition(; - lastProbeTime=nothing, - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastProbeTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human readable message indicating details about last transition. - - reason::String : (brief) reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of job condition, Complete or Failed. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1JobCondition <: OpenAPI.APIModel - lastProbeTime::Union{Nothing, ZonedDateTime} = nothing - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiBatchV1JobCondition(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("lastProbeTime"), lastProbeTime) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiBatchV1JobCondition, Symbol("type"), type) - return new(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiBatchV1JobCondition - -const _property_types_IoK8sApiBatchV1JobCondition = Dict{Symbol,String}(Symbol("lastProbeTime")=>"ZonedDateTime", Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1JobCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1JobCondition[name]))} - -function check_required(o::IoK8sApiBatchV1JobCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1JobCondition }, name::Symbol, val) - if name === Symbol("lastProbeTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobCondition", :format, val, "date-time") - end - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobList.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobList.jl deleted file mode 100644 index 09f4886f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.JobList -JobList is a collection of jobs. - - IoK8sApiBatchV1JobList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiBatchV1Job} : items is the list of Jobs. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiBatchV1JobList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiBatchV1Job} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiBatchV1JobList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiBatchV1JobList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1JobList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiBatchV1JobList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1JobList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiBatchV1JobList - -const _property_types_IoK8sApiBatchV1JobList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiBatchV1Job}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1JobList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1JobList[name]))} - -function check_required(o::IoK8sApiBatchV1JobList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1JobList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobSpec.jl deleted file mode 100644 index 83a32ded..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobSpec.jl +++ /dev/null @@ -1,75 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.JobSpec -JobSpec describes how the job execution will look like. - - IoK8sApiBatchV1JobSpec(; - activeDeadlineSeconds=nothing, - backoffLimit=nothing, - completions=nothing, - manualSelector=nothing, - parallelism=nothing, - selector=nothing, - template=nothing, - ttlSecondsAfterFinished=nothing, - ) - - - activeDeadlineSeconds::Int64 : Specifies the duration in seconds relative to the startTime that the job may be active before the system tries to terminate it; value must be positive integer - - backoffLimit::Int64 : Specifies the number of retries before marking this job failed. Defaults to 6 - - completions::Int64 : Specifies the desired number of successfully finished pods the job should be run with. Setting to nil means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ - - manualSelector::Bool : manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector - - parallelism::Int64 : Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec - - ttlSecondsAfterFinished::Int64 : ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes. This field is alpha-level and is only honored by servers that enable the TTLAfterFinished feature. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1JobSpec <: OpenAPI.APIModel - activeDeadlineSeconds::Union{Nothing, Int64} = nothing - backoffLimit::Union{Nothing, Int64} = nothing - completions::Union{Nothing, Int64} = nothing - manualSelector::Union{Nothing, Bool} = nothing - parallelism::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - ttlSecondsAfterFinished::Union{Nothing, Int64} = nothing - - function IoK8sApiBatchV1JobSpec(activeDeadlineSeconds, backoffLimit, completions, manualSelector, parallelism, selector, template, ttlSecondsAfterFinished, ) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("activeDeadlineSeconds"), activeDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("backoffLimit"), backoffLimit) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("completions"), completions) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("manualSelector"), manualSelector) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("parallelism"), parallelism) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiBatchV1JobSpec, Symbol("ttlSecondsAfterFinished"), ttlSecondsAfterFinished) - return new(activeDeadlineSeconds, backoffLimit, completions, manualSelector, parallelism, selector, template, ttlSecondsAfterFinished, ) - end -end # type IoK8sApiBatchV1JobSpec - -const _property_types_IoK8sApiBatchV1JobSpec = Dict{Symbol,String}(Symbol("activeDeadlineSeconds")=>"Int64", Symbol("backoffLimit")=>"Int64", Symbol("completions")=>"Int64", Symbol("manualSelector")=>"Bool", Symbol("parallelism")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("ttlSecondsAfterFinished")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1JobSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1JobSpec[name]))} - -function check_required(o::IoK8sApiBatchV1JobSpec) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1JobSpec }, name::Symbol, val) - if name === Symbol("activeDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobSpec", :format, val, "int64") - end - if name === Symbol("backoffLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobSpec", :format, val, "int32") - end - if name === Symbol("completions") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobSpec", :format, val, "int32") - end - if name === Symbol("parallelism") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobSpec", :format, val, "int32") - end - if name === Symbol("ttlSecondsAfterFinished") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobStatus.jl deleted file mode 100644 index f93bf0c4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobStatus.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.JobStatus -JobStatus represents the current state of a Job. - - IoK8sApiBatchV1JobStatus(; - active=nothing, - completionTime=nothing, - conditions=nothing, - failed=nothing, - startTime=nothing, - succeeded=nothing, - ) - - - active::Int64 : The number of actively running pods. - - completionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - conditions::Vector{IoK8sApiBatchV1JobCondition} : The latest available observations of an object's current state. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ - - failed::Int64 : The number of pods which reached phase Failed. - - startTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - succeeded::Int64 : The number of pods which reached phase Succeeded. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1JobStatus <: OpenAPI.APIModel - active::Union{Nothing, Int64} = nothing - completionTime::Union{Nothing, ZonedDateTime} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiBatchV1JobCondition} } - failed::Union{Nothing, Int64} = nothing - startTime::Union{Nothing, ZonedDateTime} = nothing - succeeded::Union{Nothing, Int64} = nothing - - function IoK8sApiBatchV1JobStatus(active, completionTime, conditions, failed, startTime, succeeded, ) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("active"), active) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("completionTime"), completionTime) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("failed"), failed) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("startTime"), startTime) - OpenAPI.validate_property(IoK8sApiBatchV1JobStatus, Symbol("succeeded"), succeeded) - return new(active, completionTime, conditions, failed, startTime, succeeded, ) - end -end # type IoK8sApiBatchV1JobStatus - -const _property_types_IoK8sApiBatchV1JobStatus = Dict{Symbol,String}(Symbol("active")=>"Int64", Symbol("completionTime")=>"ZonedDateTime", Symbol("conditions")=>"Vector{IoK8sApiBatchV1JobCondition}", Symbol("failed")=>"Int64", Symbol("startTime")=>"ZonedDateTime", Symbol("succeeded")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1JobStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1JobStatus[name]))} - -function check_required(o::IoK8sApiBatchV1JobStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1JobStatus }, name::Symbol, val) - if name === Symbol("active") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobStatus", :format, val, "int32") - end - if name === Symbol("completionTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobStatus", :format, val, "date-time") - end - if name === Symbol("failed") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobStatus", :format, val, "int32") - end - if name === Symbol("startTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobStatus", :format, val, "date-time") - end - if name === Symbol("succeeded") - OpenAPI.validate_param(name, "IoK8sApiBatchV1JobStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobTemplateSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobTemplateSpec.jl deleted file mode 100644 index e06335eb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1JobTemplateSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1.JobTemplateSpec -JobTemplateSpec describes the data a Job should have when created from a template - - IoK8sApiBatchV1JobTemplateSpec(; - metadata=nothing, - spec=nothing, - ) - - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1JobSpec -""" -Base.@kwdef mutable struct IoK8sApiBatchV1JobTemplateSpec <: OpenAPI.APIModel - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobSpec } - - function IoK8sApiBatchV1JobTemplateSpec(metadata, spec, ) - OpenAPI.validate_property(IoK8sApiBatchV1JobTemplateSpec, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV1JobTemplateSpec, Symbol("spec"), spec) - return new(metadata, spec, ) - end -end # type IoK8sApiBatchV1JobTemplateSpec - -const _property_types_IoK8sApiBatchV1JobTemplateSpec = Dict{Symbol,String}(Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1JobSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1JobTemplateSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1JobTemplateSpec[name]))} - -function check_required(o::IoK8sApiBatchV1JobTemplateSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1JobTemplateSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJob.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJob.jl deleted file mode 100644 index eee6066e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJob.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1beta1.CronJob -CronJob represents the configuration of a single cron job. - - IoK8sApiBatchV1beta1CronJob(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1beta1CronJobSpec - - status::IoK8sApiBatchV1beta1CronJobStatus -""" -Base.@kwdef mutable struct IoK8sApiBatchV1beta1CronJob <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1beta1CronJobSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1beta1CronJobStatus } - - function IoK8sApiBatchV1beta1CronJob(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJob, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJob, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJob, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJob, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJob, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiBatchV1beta1CronJob - -const _property_types_IoK8sApiBatchV1beta1CronJob = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1beta1CronJobSpec", Symbol("status")=>"IoK8sApiBatchV1beta1CronJobStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1beta1CronJob }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1beta1CronJob[name]))} - -function check_required(o::IoK8sApiBatchV1beta1CronJob) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1beta1CronJob }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobList.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobList.jl deleted file mode 100644 index 1c0a5b5b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1beta1.CronJobList -CronJobList is a collection of cron jobs. - - IoK8sApiBatchV1beta1CronJobList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiBatchV1beta1CronJob} : items is the list of CronJobs. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiBatchV1beta1CronJobList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiBatchV1beta1CronJob} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiBatchV1beta1CronJobList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiBatchV1beta1CronJobList - -const _property_types_IoK8sApiBatchV1beta1CronJobList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiBatchV1beta1CronJob}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1beta1CronJobList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1beta1CronJobList[name]))} - -function check_required(o::IoK8sApiBatchV1beta1CronJobList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1beta1CronJobList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobSpec.jl deleted file mode 100644 index 57aa2ea6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobSpec.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1beta1.CronJobSpec -CronJobSpec describes how the job execution will look like and when it will actually run. - - IoK8sApiBatchV1beta1CronJobSpec(; - concurrencyPolicy=nothing, - failedJobsHistoryLimit=nothing, - jobTemplate=nothing, - schedule=nothing, - startingDeadlineSeconds=nothing, - successfulJobsHistoryLimit=nothing, - suspend=nothing, - ) - - - concurrencyPolicy::String : Specifies how to treat concurrent executions of a Job. Valid values are: - \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \"Replace\": cancels currently running job and replaces it with a new one - - failedJobsHistoryLimit::Int64 : The number of failed finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. - - jobTemplate::IoK8sApiBatchV1beta1JobTemplateSpec - - schedule::String : The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. - - startingDeadlineSeconds::Int64 : Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. - - successfulJobsHistoryLimit::Int64 : The number of successful finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 3. - - suspend::Bool : This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1beta1CronJobSpec <: OpenAPI.APIModel - concurrencyPolicy::Union{Nothing, String} = nothing - failedJobsHistoryLimit::Union{Nothing, Int64} = nothing - jobTemplate = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1beta1JobTemplateSpec } - schedule::Union{Nothing, String} = nothing - startingDeadlineSeconds::Union{Nothing, Int64} = nothing - successfulJobsHistoryLimit::Union{Nothing, Int64} = nothing - suspend::Union{Nothing, Bool} = nothing - - function IoK8sApiBatchV1beta1CronJobSpec(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("concurrencyPolicy"), concurrencyPolicy) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("failedJobsHistoryLimit"), failedJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("jobTemplate"), jobTemplate) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("schedule"), schedule) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("startingDeadlineSeconds"), startingDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("successfulJobsHistoryLimit"), successfulJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobSpec, Symbol("suspend"), suspend) - return new(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - end -end # type IoK8sApiBatchV1beta1CronJobSpec - -const _property_types_IoK8sApiBatchV1beta1CronJobSpec = Dict{Symbol,String}(Symbol("concurrencyPolicy")=>"String", Symbol("failedJobsHistoryLimit")=>"Int64", Symbol("jobTemplate")=>"IoK8sApiBatchV1beta1JobTemplateSpec", Symbol("schedule")=>"String", Symbol("startingDeadlineSeconds")=>"Int64", Symbol("successfulJobsHistoryLimit")=>"Int64", Symbol("suspend")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1beta1CronJobSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1beta1CronJobSpec[name]))} - -function check_required(o::IoK8sApiBatchV1beta1CronJobSpec) - o.jobTemplate === nothing && (return false) - o.schedule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1beta1CronJobSpec }, name::Symbol, val) - if name === Symbol("failedJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV1beta1CronJobSpec", :format, val, "int32") - end - if name === Symbol("startingDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiBatchV1beta1CronJobSpec", :format, val, "int64") - end - if name === Symbol("successfulJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV1beta1CronJobSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobStatus.jl deleted file mode 100644 index 3d4de2d4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1CronJobStatus.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1beta1.CronJobStatus -CronJobStatus represents the current state of a cron job. - - IoK8sApiBatchV1beta1CronJobStatus(; - active=nothing, - lastScheduleTime=nothing, - lastSuccessfulTime=nothing, - ) - - - active::Vector{IoK8sApiCoreV1ObjectReference} : A list of pointers to currently running jobs. - - lastScheduleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastSuccessfulTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiBatchV1beta1CronJobStatus <: OpenAPI.APIModel - active::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ObjectReference} } - lastScheduleTime::Union{Nothing, ZonedDateTime} = nothing - lastSuccessfulTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiBatchV1beta1CronJobStatus(active, lastScheduleTime, lastSuccessfulTime, ) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobStatus, Symbol("active"), active) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobStatus, Symbol("lastScheduleTime"), lastScheduleTime) - OpenAPI.validate_property(IoK8sApiBatchV1beta1CronJobStatus, Symbol("lastSuccessfulTime"), lastSuccessfulTime) - return new(active, lastScheduleTime, lastSuccessfulTime, ) - end -end # type IoK8sApiBatchV1beta1CronJobStatus - -const _property_types_IoK8sApiBatchV1beta1CronJobStatus = Dict{Symbol,String}(Symbol("active")=>"Vector{IoK8sApiCoreV1ObjectReference}", Symbol("lastScheduleTime")=>"ZonedDateTime", Symbol("lastSuccessfulTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1beta1CronJobStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1beta1CronJobStatus[name]))} - -function check_required(o::IoK8sApiBatchV1beta1CronJobStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1beta1CronJobStatus }, name::Symbol, val) - if name === Symbol("lastScheduleTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1beta1CronJobStatus", :format, val, "date-time") - end - if name === Symbol("lastSuccessfulTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV1beta1CronJobStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1JobTemplateSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1JobTemplateSpec.jl deleted file mode 100644 index 2a628773..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV1beta1JobTemplateSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v1beta1.JobTemplateSpec -JobTemplateSpec describes the data a Job should have when created from a template - - IoK8sApiBatchV1beta1JobTemplateSpec(; - metadata=nothing, - spec=nothing, - ) - - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1JobSpec -""" -Base.@kwdef mutable struct IoK8sApiBatchV1beta1JobTemplateSpec <: OpenAPI.APIModel - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobSpec } - - function IoK8sApiBatchV1beta1JobTemplateSpec(metadata, spec, ) - OpenAPI.validate_property(IoK8sApiBatchV1beta1JobTemplateSpec, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV1beta1JobTemplateSpec, Symbol("spec"), spec) - return new(metadata, spec, ) - end -end # type IoK8sApiBatchV1beta1JobTemplateSpec - -const _property_types_IoK8sApiBatchV1beta1JobTemplateSpec = Dict{Symbol,String}(Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1JobSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV1beta1JobTemplateSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV1beta1JobTemplateSpec[name]))} - -function check_required(o::IoK8sApiBatchV1beta1JobTemplateSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV1beta1JobTemplateSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJob.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJob.jl deleted file mode 100644 index 2f121256..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJob.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v2alpha1.CronJob -CronJob represents the configuration of a single cron job. - - IoK8sApiBatchV2alpha1CronJob(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV2alpha1CronJobSpec - - status::IoK8sApiBatchV2alpha1CronJobStatus -""" -Base.@kwdef mutable struct IoK8sApiBatchV2alpha1CronJob <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV2alpha1CronJobSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiBatchV2alpha1CronJobStatus } - - function IoK8sApiBatchV2alpha1CronJob(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJob, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJob, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJob, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJob, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJob, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiBatchV2alpha1CronJob - -const _property_types_IoK8sApiBatchV2alpha1CronJob = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV2alpha1CronJobSpec", Symbol("status")=>"IoK8sApiBatchV2alpha1CronJobStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV2alpha1CronJob }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV2alpha1CronJob[name]))} - -function check_required(o::IoK8sApiBatchV2alpha1CronJob) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV2alpha1CronJob }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobList.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobList.jl deleted file mode 100644 index 3676ecdf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v2alpha1.CronJobList -CronJobList is a collection of cron jobs. - - IoK8sApiBatchV2alpha1CronJobList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiBatchV2alpha1CronJob} : items is the list of CronJobs. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiBatchV2alpha1CronJobList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiBatchV2alpha1CronJob} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiBatchV2alpha1CronJobList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiBatchV2alpha1CronJobList - -const _property_types_IoK8sApiBatchV2alpha1CronJobList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiBatchV2alpha1CronJob}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV2alpha1CronJobList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV2alpha1CronJobList[name]))} - -function check_required(o::IoK8sApiBatchV2alpha1CronJobList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV2alpha1CronJobList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobSpec.jl deleted file mode 100644 index 218201fb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobSpec.jl +++ /dev/null @@ -1,66 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v2alpha1.CronJobSpec -CronJobSpec describes how the job execution will look like and when it will actually run. - - IoK8sApiBatchV2alpha1CronJobSpec(; - concurrencyPolicy=nothing, - failedJobsHistoryLimit=nothing, - jobTemplate=nothing, - schedule=nothing, - startingDeadlineSeconds=nothing, - successfulJobsHistoryLimit=nothing, - suspend=nothing, - ) - - - concurrencyPolicy::String : Specifies how to treat concurrent executions of a Job. Valid values are: - \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \"Replace\": cancels currently running job and replaces it with a new one - - failedJobsHistoryLimit::Int64 : The number of failed finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. - - jobTemplate::IoK8sApiBatchV2alpha1JobTemplateSpec - - schedule::String : The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. - - startingDeadlineSeconds::Int64 : Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. - - successfulJobsHistoryLimit::Int64 : The number of successful finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. - - suspend::Bool : This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. -""" -Base.@kwdef mutable struct IoK8sApiBatchV2alpha1CronJobSpec <: OpenAPI.APIModel - concurrencyPolicy::Union{Nothing, String} = nothing - failedJobsHistoryLimit::Union{Nothing, Int64} = nothing - jobTemplate = nothing # spec type: Union{ Nothing, IoK8sApiBatchV2alpha1JobTemplateSpec } - schedule::Union{Nothing, String} = nothing - startingDeadlineSeconds::Union{Nothing, Int64} = nothing - successfulJobsHistoryLimit::Union{Nothing, Int64} = nothing - suspend::Union{Nothing, Bool} = nothing - - function IoK8sApiBatchV2alpha1CronJobSpec(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("concurrencyPolicy"), concurrencyPolicy) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("failedJobsHistoryLimit"), failedJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("jobTemplate"), jobTemplate) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("schedule"), schedule) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("startingDeadlineSeconds"), startingDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("successfulJobsHistoryLimit"), successfulJobsHistoryLimit) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobSpec, Symbol("suspend"), suspend) - return new(concurrencyPolicy, failedJobsHistoryLimit, jobTemplate, schedule, startingDeadlineSeconds, successfulJobsHistoryLimit, suspend, ) - end -end # type IoK8sApiBatchV2alpha1CronJobSpec - -const _property_types_IoK8sApiBatchV2alpha1CronJobSpec = Dict{Symbol,String}(Symbol("concurrencyPolicy")=>"String", Symbol("failedJobsHistoryLimit")=>"Int64", Symbol("jobTemplate")=>"IoK8sApiBatchV2alpha1JobTemplateSpec", Symbol("schedule")=>"String", Symbol("startingDeadlineSeconds")=>"Int64", Symbol("successfulJobsHistoryLimit")=>"Int64", Symbol("suspend")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV2alpha1CronJobSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV2alpha1CronJobSpec[name]))} - -function check_required(o::IoK8sApiBatchV2alpha1CronJobSpec) - o.jobTemplate === nothing && (return false) - o.schedule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV2alpha1CronJobSpec }, name::Symbol, val) - if name === Symbol("failedJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV2alpha1CronJobSpec", :format, val, "int32") - end - if name === Symbol("startingDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiBatchV2alpha1CronJobSpec", :format, val, "int64") - end - if name === Symbol("successfulJobsHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiBatchV2alpha1CronJobSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobStatus.jl deleted file mode 100644 index 0f8456ae..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1CronJobStatus.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v2alpha1.CronJobStatus -CronJobStatus represents the current state of a cron job. - - IoK8sApiBatchV2alpha1CronJobStatus(; - active=nothing, - lastScheduleTime=nothing, - ) - - - active::Vector{IoK8sApiCoreV1ObjectReference} : A list of pointers to currently running jobs. - - lastScheduleTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiBatchV2alpha1CronJobStatus <: OpenAPI.APIModel - active::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ObjectReference} } - lastScheduleTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiBatchV2alpha1CronJobStatus(active, lastScheduleTime, ) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobStatus, Symbol("active"), active) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1CronJobStatus, Symbol("lastScheduleTime"), lastScheduleTime) - return new(active, lastScheduleTime, ) - end -end # type IoK8sApiBatchV2alpha1CronJobStatus - -const _property_types_IoK8sApiBatchV2alpha1CronJobStatus = Dict{Symbol,String}(Symbol("active")=>"Vector{IoK8sApiCoreV1ObjectReference}", Symbol("lastScheduleTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV2alpha1CronJobStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV2alpha1CronJobStatus[name]))} - -function check_required(o::IoK8sApiBatchV2alpha1CronJobStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV2alpha1CronJobStatus }, name::Symbol, val) - if name === Symbol("lastScheduleTime") - OpenAPI.validate_param(name, "IoK8sApiBatchV2alpha1CronJobStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1JobTemplateSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1JobTemplateSpec.jl deleted file mode 100644 index 5f74c6a7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiBatchV2alpha1JobTemplateSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.batch.v2alpha1.JobTemplateSpec -JobTemplateSpec describes the data a Job should have when created from a template - - IoK8sApiBatchV2alpha1JobTemplateSpec(; - metadata=nothing, - spec=nothing, - ) - - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiBatchV1JobSpec -""" -Base.@kwdef mutable struct IoK8sApiBatchV2alpha1JobTemplateSpec <: OpenAPI.APIModel - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiBatchV1JobSpec } - - function IoK8sApiBatchV2alpha1JobTemplateSpec(metadata, spec, ) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1JobTemplateSpec, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiBatchV2alpha1JobTemplateSpec, Symbol("spec"), spec) - return new(metadata, spec, ) - end -end # type IoK8sApiBatchV2alpha1JobTemplateSpec - -const _property_types_IoK8sApiBatchV2alpha1JobTemplateSpec = Dict{Symbol,String}(Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiBatchV1JobSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiBatchV2alpha1JobTemplateSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiBatchV2alpha1JobTemplateSpec[name]))} - -function check_required(o::IoK8sApiBatchV2alpha1JobTemplateSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiBatchV2alpha1JobTemplateSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequest.jl b/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequest.jl deleted file mode 100644 index e3e75952..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequest.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.certificates.v1beta1.CertificateSigningRequest -Describes a certificate signing request - - IoK8sApiCertificatesV1beta1CertificateSigningRequest(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec - - status::IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus -""" -Base.@kwdef mutable struct IoK8sApiCertificatesV1beta1CertificateSigningRequest <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus } - - function IoK8sApiCertificatesV1beta1CertificateSigningRequest(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequest, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequest, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequest, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequest, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequest, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCertificatesV1beta1CertificateSigningRequest - -const _property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequest = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec", Symbol("status")=>"IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequest }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequest[name]))} - -function check_required(o::IoK8sApiCertificatesV1beta1CertificateSigningRequest) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequest }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition.jl deleted file mode 100644 index 95f0608d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition - - IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition(; - lastUpdateTime=nothing, - message=nothing, - reason=nothing, - type=nothing, - ) - - - lastUpdateTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : human readable message with details about the request state - - reason::String : brief reason for the request state - - type::String : request approval state, currently Approved or Denied. -""" -Base.@kwdef mutable struct IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition <: OpenAPI.APIModel - lastUpdateTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition(lastUpdateTime, message, reason, type, ) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition, Symbol("lastUpdateTime"), lastUpdateTime) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition, Symbol("type"), type) - return new(lastUpdateTime, message, reason, type, ) - end -end # type IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition - -const _property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition = Dict{Symbol,String}(Symbol("lastUpdateTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition[name]))} - -function check_required(o::IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition }, name::Symbol, val) - if name === Symbol("lastUpdateTime") - OpenAPI.validate_param(name, "IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestList.jl b/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestList.jl deleted file mode 100644 index a13689e1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestList.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.certificates.v1beta1.CertificateSigningRequestList - - IoK8sApiCertificatesV1beta1CertificateSigningRequestList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequest} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCertificatesV1beta1CertificateSigningRequestList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequest} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCertificatesV1beta1CertificateSigningRequestList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCertificatesV1beta1CertificateSigningRequestList - -const _property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequest}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestList[name]))} - -function check_required(o::IoK8sApiCertificatesV1beta1CertificateSigningRequestList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec.jl deleted file mode 100644 index 188feb1c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec.jl +++ /dev/null @@ -1,58 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec -This information is immutable after the request is created. Only the Request and Usages fields can be set on creation, other fields are derived by Kubernetes and cannot be modified by users. - - IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec(; - extra=nothing, - groups=nothing, - request=nothing, - uid=nothing, - usages=nothing, - username=nothing, - ) - - - extra::Dict{String, Vector{String}} : Extra information about the requesting user. See user.Info interface for details. - - groups::Vector{String} : Group information about the requesting user. See user.Info interface for details. - - request::Vector{UInt8} : Base64-encoded PKCS#10 CSR data - - uid::String : UID information about the requesting user. See user.Info interface for details. - - usages::Vector{String} : allowedUsages specifies a set of usage contexts the key will be valid for. See: https://tools.ietf.org/html/rfc5280#section-4.2.1.3 https://tools.ietf.org/html/rfc5280#section-4.2.1.12 - - username::String : Information about the requesting user. See user.Info interface for details. -""" -Base.@kwdef mutable struct IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec <: OpenAPI.APIModel - extra::Union{Nothing, Dict{String, Vector{String}}} = nothing - groups::Union{Nothing, Vector{String}} = nothing - request::Union{Nothing, Vector{UInt8}} = nothing - uid::Union{Nothing, String} = nothing - usages::Union{Nothing, Vector{String}} = nothing - username::Union{Nothing, String} = nothing - - function IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec(extra, groups, request, uid, usages, username, ) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("extra"), extra) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("groups"), groups) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("request"), request) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("uid"), uid) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("usages"), usages) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec, Symbol("username"), username) - return new(extra, groups, request, uid, usages, username, ) - end -end # type IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec - -const _property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec = Dict{Symbol,String}(Symbol("extra")=>"Dict{String, Vector{String}}", Symbol("groups")=>"Vector{String}", Symbol("request")=>"Vector{UInt8}", Symbol("uid")=>"String", Symbol("usages")=>"Vector{String}", Symbol("username")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec[name]))} - -function check_required(o::IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec) - o.request === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec }, name::Symbol, val) - if name === Symbol("request") - OpenAPI.validate_param(name, "IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec", :format, val, "byte") - end - if name === Symbol("request") - OpenAPI.validate_param(name, "IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus.jl deleted file mode 100644 index ff536d19..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus - - IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus(; - certificate=nothing, - conditions=nothing, - ) - - - certificate::Vector{UInt8} : If request was approved, the controller will place the issued certificate here. - - conditions::Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition} : Conditions applied to the request, such as approval or denial. -""" -Base.@kwdef mutable struct IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus <: OpenAPI.APIModel - certificate::Union{Nothing, Vector{UInt8}} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition} } - - function IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus(certificate, conditions, ) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus, Symbol("certificate"), certificate) - OpenAPI.validate_property(IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus, Symbol("conditions"), conditions) - return new(certificate, conditions, ) - end -end # type IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus - -const _property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus = Dict{Symbol,String}(Symbol("certificate")=>"Vector{UInt8}", Symbol("conditions")=>"Vector{IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition}", ) -OpenAPI.property_type(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus[name]))} - -function check_required(o::IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus }, name::Symbol, val) - if name === Symbol("certificate") - OpenAPI.validate_param(name, "IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus", :format, val, "byte") - end - if name === Symbol("certificate") - OpenAPI.validate_param(name, "IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1Lease.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1Lease.jl deleted file mode 100644 index 7d2161ef..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1Lease.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1.Lease -Lease defines a lease concept. - - IoK8sApiCoordinationV1Lease(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoordinationV1LeaseSpec -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1Lease <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoordinationV1LeaseSpec } - - function IoK8sApiCoordinationV1Lease(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1Lease, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoordinationV1Lease, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoordinationV1Lease, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoordinationV1Lease, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiCoordinationV1Lease - -const _property_types_IoK8sApiCoordinationV1Lease = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoordinationV1LeaseSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1Lease }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1Lease[name]))} - -function check_required(o::IoK8sApiCoordinationV1Lease) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1Lease }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseList.jl deleted file mode 100644 index 2cff2d21..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1.LeaseList -LeaseList is a list of Lease objects. - - IoK8sApiCoordinationV1LeaseList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoordinationV1Lease} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1LeaseList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoordinationV1Lease} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoordinationV1LeaseList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoordinationV1LeaseList - -const _property_types_IoK8sApiCoordinationV1LeaseList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoordinationV1Lease}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1LeaseList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1LeaseList[name]))} - -function check_required(o::IoK8sApiCoordinationV1LeaseList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1LeaseList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseSpec.jl deleted file mode 100644 index c0eb2ab7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1LeaseSpec.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1.LeaseSpec -LeaseSpec is a specification of a Lease. - - IoK8sApiCoordinationV1LeaseSpec(; - acquireTime=nothing, - holderIdentity=nothing, - leaseDurationSeconds=nothing, - leaseTransitions=nothing, - renewTime=nothing, - ) - - - acquireTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - holderIdentity::String : holderIdentity contains the identity of the holder of a current lease. - - leaseDurationSeconds::Int64 : leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measure against time of last observed RenewTime. - - leaseTransitions::Int64 : leaseTransitions is the number of transitions of a lease between holders. - - renewTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1LeaseSpec <: OpenAPI.APIModel - acquireTime::Union{Nothing, ZonedDateTime} = nothing - holderIdentity::Union{Nothing, String} = nothing - leaseDurationSeconds::Union{Nothing, Int64} = nothing - leaseTransitions::Union{Nothing, Int64} = nothing - renewTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiCoordinationV1LeaseSpec(acquireTime, holderIdentity, leaseDurationSeconds, leaseTransitions, renewTime, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseSpec, Symbol("acquireTime"), acquireTime) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseSpec, Symbol("holderIdentity"), holderIdentity) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseSpec, Symbol("leaseDurationSeconds"), leaseDurationSeconds) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseSpec, Symbol("leaseTransitions"), leaseTransitions) - OpenAPI.validate_property(IoK8sApiCoordinationV1LeaseSpec, Symbol("renewTime"), renewTime) - return new(acquireTime, holderIdentity, leaseDurationSeconds, leaseTransitions, renewTime, ) - end -end # type IoK8sApiCoordinationV1LeaseSpec - -const _property_types_IoK8sApiCoordinationV1LeaseSpec = Dict{Symbol,String}(Symbol("acquireTime")=>"ZonedDateTime", Symbol("holderIdentity")=>"String", Symbol("leaseDurationSeconds")=>"Int64", Symbol("leaseTransitions")=>"Int64", Symbol("renewTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1LeaseSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1LeaseSpec[name]))} - -function check_required(o::IoK8sApiCoordinationV1LeaseSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1LeaseSpec }, name::Symbol, val) - if name === Symbol("acquireTime") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1LeaseSpec", :format, val, "date-time") - end - if name === Symbol("leaseDurationSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1LeaseSpec", :format, val, "int32") - end - if name === Symbol("leaseTransitions") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1LeaseSpec", :format, val, "int32") - end - if name === Symbol("renewTime") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1LeaseSpec", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1Lease.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1Lease.jl deleted file mode 100644 index ddab6bef..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1Lease.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1beta1.Lease -Lease defines a lease concept. - - IoK8sApiCoordinationV1beta1Lease(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoordinationV1beta1LeaseSpec -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1beta1Lease <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoordinationV1beta1LeaseSpec } - - function IoK8sApiCoordinationV1beta1Lease(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1Lease, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1Lease, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1Lease, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1Lease, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiCoordinationV1beta1Lease - -const _property_types_IoK8sApiCoordinationV1beta1Lease = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoordinationV1beta1LeaseSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1beta1Lease }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1beta1Lease[name]))} - -function check_required(o::IoK8sApiCoordinationV1beta1Lease) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1beta1Lease }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseList.jl deleted file mode 100644 index 455bba56..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1beta1.LeaseList -LeaseList is a list of Lease objects. - - IoK8sApiCoordinationV1beta1LeaseList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoordinationV1beta1Lease} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1beta1LeaseList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoordinationV1beta1Lease} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoordinationV1beta1LeaseList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoordinationV1beta1LeaseList - -const _property_types_IoK8sApiCoordinationV1beta1LeaseList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoordinationV1beta1Lease}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1beta1LeaseList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1beta1LeaseList[name]))} - -function check_required(o::IoK8sApiCoordinationV1beta1LeaseList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1beta1LeaseList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseSpec.jl deleted file mode 100644 index 65e23d63..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoordinationV1beta1LeaseSpec.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.coordination.v1beta1.LeaseSpec -LeaseSpec is a specification of a Lease. - - IoK8sApiCoordinationV1beta1LeaseSpec(; - acquireTime=nothing, - holderIdentity=nothing, - leaseDurationSeconds=nothing, - leaseTransitions=nothing, - renewTime=nothing, - ) - - - acquireTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - holderIdentity::String : holderIdentity contains the identity of the holder of a current lease. - - leaseDurationSeconds::Int64 : leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measure against time of last observed RenewTime. - - leaseTransitions::Int64 : leaseTransitions is the number of transitions of a lease between holders. - - renewTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. -""" -Base.@kwdef mutable struct IoK8sApiCoordinationV1beta1LeaseSpec <: OpenAPI.APIModel - acquireTime::Union{Nothing, ZonedDateTime} = nothing - holderIdentity::Union{Nothing, String} = nothing - leaseDurationSeconds::Union{Nothing, Int64} = nothing - leaseTransitions::Union{Nothing, Int64} = nothing - renewTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiCoordinationV1beta1LeaseSpec(acquireTime, holderIdentity, leaseDurationSeconds, leaseTransitions, renewTime, ) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseSpec, Symbol("acquireTime"), acquireTime) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseSpec, Symbol("holderIdentity"), holderIdentity) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseSpec, Symbol("leaseDurationSeconds"), leaseDurationSeconds) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseSpec, Symbol("leaseTransitions"), leaseTransitions) - OpenAPI.validate_property(IoK8sApiCoordinationV1beta1LeaseSpec, Symbol("renewTime"), renewTime) - return new(acquireTime, holderIdentity, leaseDurationSeconds, leaseTransitions, renewTime, ) - end -end # type IoK8sApiCoordinationV1beta1LeaseSpec - -const _property_types_IoK8sApiCoordinationV1beta1LeaseSpec = Dict{Symbol,String}(Symbol("acquireTime")=>"ZonedDateTime", Symbol("holderIdentity")=>"String", Symbol("leaseDurationSeconds")=>"Int64", Symbol("leaseTransitions")=>"Int64", Symbol("renewTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiCoordinationV1beta1LeaseSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoordinationV1beta1LeaseSpec[name]))} - -function check_required(o::IoK8sApiCoordinationV1beta1LeaseSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoordinationV1beta1LeaseSpec }, name::Symbol, val) - if name === Symbol("acquireTime") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1beta1LeaseSpec", :format, val, "date-time") - end - if name === Symbol("leaseDurationSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1beta1LeaseSpec", :format, val, "int32") - end - if name === Symbol("leaseTransitions") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1beta1LeaseSpec", :format, val, "int32") - end - if name === Symbol("renewTime") - OpenAPI.validate_param(name, "IoK8sApiCoordinationV1beta1LeaseSpec", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource.jl deleted file mode 100644 index ef50b63d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource -Represents a Persistent Disk resource in AWS. An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(; - fsType=nothing, - partition=nothing, - readOnly=nothing, - volumeID=nothing, - ) - - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore - - partition::Int64 : The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). - - readOnly::Bool : Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\". If omitted, the default is \"false\". More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore - - volumeID::String : Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore -""" -Base.@kwdef mutable struct IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - partition::Union{Nothing, Int64} = nothing - readOnly::Union{Nothing, Bool} = nothing - volumeID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(fsType, partition, readOnly, volumeID, ) - OpenAPI.validate_property(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, Symbol("partition"), partition) - OpenAPI.validate_property(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, Symbol("volumeID"), volumeID) - return new(fsType, partition, readOnly, volumeID, ) - end -end # type IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - -const _property_types_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("partition")=>"Int64", Symbol("readOnly")=>"Bool", Symbol("volumeID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) - o.volumeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource }, name::Symbol, val) - if name === Symbol("partition") - OpenAPI.validate_param(name, "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Affinity.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Affinity.jl deleted file mode 100644 index 6991d175..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Affinity.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Affinity -Affinity is a group of affinity scheduling rules. - - IoK8sApiCoreV1Affinity(; - nodeAffinity=nothing, - podAffinity=nothing, - podAntiAffinity=nothing, - ) - - - nodeAffinity::IoK8sApiCoreV1NodeAffinity - - podAffinity::IoK8sApiCoreV1PodAffinity - - podAntiAffinity::IoK8sApiCoreV1PodAntiAffinity -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Affinity <: OpenAPI.APIModel - nodeAffinity = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeAffinity } - podAffinity = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodAffinity } - podAntiAffinity = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodAntiAffinity } - - function IoK8sApiCoreV1Affinity(nodeAffinity, podAffinity, podAntiAffinity, ) - OpenAPI.validate_property(IoK8sApiCoreV1Affinity, Symbol("nodeAffinity"), nodeAffinity) - OpenAPI.validate_property(IoK8sApiCoreV1Affinity, Symbol("podAffinity"), podAffinity) - OpenAPI.validate_property(IoK8sApiCoreV1Affinity, Symbol("podAntiAffinity"), podAntiAffinity) - return new(nodeAffinity, podAffinity, podAntiAffinity, ) - end -end # type IoK8sApiCoreV1Affinity - -const _property_types_IoK8sApiCoreV1Affinity = Dict{Symbol,String}(Symbol("nodeAffinity")=>"IoK8sApiCoreV1NodeAffinity", Symbol("podAffinity")=>"IoK8sApiCoreV1PodAffinity", Symbol("podAntiAffinity")=>"IoK8sApiCoreV1PodAntiAffinity", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Affinity }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Affinity[name]))} - -function check_required(o::IoK8sApiCoreV1Affinity) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Affinity }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AttachedVolume.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1AttachedVolume.jl deleted file mode 100644 index 39b027c3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AttachedVolume.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.AttachedVolume -AttachedVolume describes a volume attached to a node - - IoK8sApiCoreV1AttachedVolume(; - devicePath=nothing, - name=nothing, - ) - - - devicePath::String : DevicePath represents the device path where the volume should be available - - name::String : Name of the attached volume -""" -Base.@kwdef mutable struct IoK8sApiCoreV1AttachedVolume <: OpenAPI.APIModel - devicePath::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1AttachedVolume(devicePath, name, ) - OpenAPI.validate_property(IoK8sApiCoreV1AttachedVolume, Symbol("devicePath"), devicePath) - OpenAPI.validate_property(IoK8sApiCoreV1AttachedVolume, Symbol("name"), name) - return new(devicePath, name, ) - end -end # type IoK8sApiCoreV1AttachedVolume - -const _property_types_IoK8sApiCoreV1AttachedVolume = Dict{Symbol,String}(Symbol("devicePath")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1AttachedVolume }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1AttachedVolume[name]))} - -function check_required(o::IoK8sApiCoreV1AttachedVolume) - o.devicePath === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1AttachedVolume }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureDiskVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureDiskVolumeSource.jl deleted file mode 100644 index 93952675..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureDiskVolumeSource.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.AzureDiskVolumeSource -AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. - - IoK8sApiCoreV1AzureDiskVolumeSource(; - cachingMode=nothing, - diskName=nothing, - diskURI=nothing, - fsType=nothing, - kind=nothing, - readOnly=nothing, - ) - - - cachingMode::String : Host Caching mode: None, Read Only, Read Write. - - diskName::String : The Name of the data disk in the blob storage - - diskURI::String : The URI the data disk in the blob storage - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - kind::String : Expected values Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1AzureDiskVolumeSource <: OpenAPI.APIModel - cachingMode::Union{Nothing, String} = nothing - diskName::Union{Nothing, String} = nothing - diskURI::Union{Nothing, String} = nothing - fsType::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1AzureDiskVolumeSource(cachingMode, diskName, diskURI, fsType, kind, readOnly, ) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("cachingMode"), cachingMode) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("diskName"), diskName) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("diskURI"), diskURI) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1AzureDiskVolumeSource, Symbol("readOnly"), readOnly) - return new(cachingMode, diskName, diskURI, fsType, kind, readOnly, ) - end -end # type IoK8sApiCoreV1AzureDiskVolumeSource - -const _property_types_IoK8sApiCoreV1AzureDiskVolumeSource = Dict{Symbol,String}(Symbol("cachingMode")=>"String", Symbol("diskName")=>"String", Symbol("diskURI")=>"String", Symbol("fsType")=>"String", Symbol("kind")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1AzureDiskVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1AzureDiskVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1AzureDiskVolumeSource) - o.diskName === nothing && (return false) - o.diskURI === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1AzureDiskVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFilePersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFilePersistentVolumeSource.jl deleted file mode 100644 index 9a424a2e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFilePersistentVolumeSource.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.AzureFilePersistentVolumeSource -AzureFile represents an Azure File Service mount on the host and bind mount to the pod. - - IoK8sApiCoreV1AzureFilePersistentVolumeSource(; - readOnly=nothing, - secretName=nothing, - secretNamespace=nothing, - shareName=nothing, - ) - - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretName::String : the name of secret that contains Azure Storage Account Name and Key - - secretNamespace::String : the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod - - shareName::String : Share Name -""" -Base.@kwdef mutable struct IoK8sApiCoreV1AzureFilePersistentVolumeSource <: OpenAPI.APIModel - readOnly::Union{Nothing, Bool} = nothing - secretName::Union{Nothing, String} = nothing - secretNamespace::Union{Nothing, String} = nothing - shareName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1AzureFilePersistentVolumeSource(readOnly, secretName, secretNamespace, shareName, ) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFilePersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFilePersistentVolumeSource, Symbol("secretName"), secretName) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFilePersistentVolumeSource, Symbol("secretNamespace"), secretNamespace) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFilePersistentVolumeSource, Symbol("shareName"), shareName) - return new(readOnly, secretName, secretNamespace, shareName, ) - end -end # type IoK8sApiCoreV1AzureFilePersistentVolumeSource - -const _property_types_IoK8sApiCoreV1AzureFilePersistentVolumeSource = Dict{Symbol,String}(Symbol("readOnly")=>"Bool", Symbol("secretName")=>"String", Symbol("secretNamespace")=>"String", Symbol("shareName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1AzureFilePersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1AzureFilePersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1AzureFilePersistentVolumeSource) - o.secretName === nothing && (return false) - o.shareName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1AzureFilePersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFileVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFileVolumeSource.jl deleted file mode 100644 index d8da9357..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1AzureFileVolumeSource.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.AzureFileVolumeSource -AzureFile represents an Azure File Service mount on the host and bind mount to the pod. - - IoK8sApiCoreV1AzureFileVolumeSource(; - readOnly=nothing, - secretName=nothing, - shareName=nothing, - ) - - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretName::String : the name of secret that contains Azure Storage Account Name and Key - - shareName::String : Share Name -""" -Base.@kwdef mutable struct IoK8sApiCoreV1AzureFileVolumeSource <: OpenAPI.APIModel - readOnly::Union{Nothing, Bool} = nothing - secretName::Union{Nothing, String} = nothing - shareName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1AzureFileVolumeSource(readOnly, secretName, shareName, ) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFileVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFileVolumeSource, Symbol("secretName"), secretName) - OpenAPI.validate_property(IoK8sApiCoreV1AzureFileVolumeSource, Symbol("shareName"), shareName) - return new(readOnly, secretName, shareName, ) - end -end # type IoK8sApiCoreV1AzureFileVolumeSource - -const _property_types_IoK8sApiCoreV1AzureFileVolumeSource = Dict{Symbol,String}(Symbol("readOnly")=>"Bool", Symbol("secretName")=>"String", Symbol("shareName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1AzureFileVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1AzureFileVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1AzureFileVolumeSource) - o.secretName === nothing && (return false) - o.shareName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1AzureFileVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Binding.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Binding.jl deleted file mode 100644 index 4337609c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Binding.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Binding -Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead. - - IoK8sApiCoreV1Binding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - target=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - target::IoK8sApiCoreV1ObjectReference -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Binding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - target = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - - function IoK8sApiCoreV1Binding(apiVersion, kind, metadata, target, ) - OpenAPI.validate_property(IoK8sApiCoreV1Binding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Binding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Binding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Binding, Symbol("target"), target) - return new(apiVersion, kind, metadata, target, ) - end -end # type IoK8sApiCoreV1Binding - -const _property_types_IoK8sApiCoreV1Binding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("target")=>"IoK8sApiCoreV1ObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Binding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Binding[name]))} - -function check_required(o::IoK8sApiCoreV1Binding) - o.target === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Binding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIPersistentVolumeSource.jl deleted file mode 100644 index 6bd801d1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIPersistentVolumeSource.jl +++ /dev/null @@ -1,65 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CSIPersistentVolumeSource -Represents storage that is managed by an external CSI volume driver (Beta feature) - - IoK8sApiCoreV1CSIPersistentVolumeSource(; - controllerExpandSecretRef=nothing, - controllerPublishSecretRef=nothing, - driver=nothing, - fsType=nothing, - nodePublishSecretRef=nothing, - nodeStageSecretRef=nothing, - readOnly=nothing, - volumeAttributes=nothing, - volumeHandle=nothing, - ) - - - controllerExpandSecretRef::IoK8sApiCoreV1SecretReference - - controllerPublishSecretRef::IoK8sApiCoreV1SecretReference - - driver::String : Driver is the name of the driver to use for this volume. Required. - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". - - nodePublishSecretRef::IoK8sApiCoreV1SecretReference - - nodeStageSecretRef::IoK8sApiCoreV1SecretReference - - readOnly::Bool : Optional: The value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write). - - volumeAttributes::Dict{String, String} : Attributes of the volume to publish. - - volumeHandle::String : VolumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CSIPersistentVolumeSource <: OpenAPI.APIModel - controllerExpandSecretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - controllerPublishSecretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - driver::Union{Nothing, String} = nothing - fsType::Union{Nothing, String} = nothing - nodePublishSecretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - nodeStageSecretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - readOnly::Union{Nothing, Bool} = nothing - volumeAttributes::Union{Nothing, Dict{String, String}} = nothing - volumeHandle::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1CSIPersistentVolumeSource(controllerExpandSecretRef, controllerPublishSecretRef, driver, fsType, nodePublishSecretRef, nodeStageSecretRef, readOnly, volumeAttributes, volumeHandle, ) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("controllerExpandSecretRef"), controllerExpandSecretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("controllerPublishSecretRef"), controllerPublishSecretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("driver"), driver) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("nodePublishSecretRef"), nodePublishSecretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("nodeStageSecretRef"), nodeStageSecretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("volumeAttributes"), volumeAttributes) - OpenAPI.validate_property(IoK8sApiCoreV1CSIPersistentVolumeSource, Symbol("volumeHandle"), volumeHandle) - return new(controllerExpandSecretRef, controllerPublishSecretRef, driver, fsType, nodePublishSecretRef, nodeStageSecretRef, readOnly, volumeAttributes, volumeHandle, ) - end -end # type IoK8sApiCoreV1CSIPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1CSIPersistentVolumeSource = Dict{Symbol,String}(Symbol("controllerExpandSecretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("controllerPublishSecretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("driver")=>"String", Symbol("fsType")=>"String", Symbol("nodePublishSecretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("nodeStageSecretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("readOnly")=>"Bool", Symbol("volumeAttributes")=>"Dict{String, String}", Symbol("volumeHandle")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CSIPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CSIPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CSIPersistentVolumeSource) - o.driver === nothing && (return false) - o.volumeHandle === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CSIPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIVolumeSource.jl deleted file mode 100644 index 5b195f50..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CSIVolumeSource.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CSIVolumeSource -Represents a source location of a volume to mount, managed by an external CSI driver - - IoK8sApiCoreV1CSIVolumeSource(; - driver=nothing, - fsType=nothing, - nodePublishSecretRef=nothing, - readOnly=nothing, - volumeAttributes=nothing, - ) - - - driver::String : Driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster. - - fsType::String : Filesystem type to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply. - - nodePublishSecretRef::IoK8sApiCoreV1LocalObjectReference - - readOnly::Bool : Specifies a read-only configuration for the volume. Defaults to false (read/write). - - volumeAttributes::Dict{String, String} : VolumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CSIVolumeSource <: OpenAPI.APIModel - driver::Union{Nothing, String} = nothing - fsType::Union{Nothing, String} = nothing - nodePublishSecretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - readOnly::Union{Nothing, Bool} = nothing - volumeAttributes::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiCoreV1CSIVolumeSource(driver, fsType, nodePublishSecretRef, readOnly, volumeAttributes, ) - OpenAPI.validate_property(IoK8sApiCoreV1CSIVolumeSource, Symbol("driver"), driver) - OpenAPI.validate_property(IoK8sApiCoreV1CSIVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1CSIVolumeSource, Symbol("nodePublishSecretRef"), nodePublishSecretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CSIVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CSIVolumeSource, Symbol("volumeAttributes"), volumeAttributes) - return new(driver, fsType, nodePublishSecretRef, readOnly, volumeAttributes, ) - end -end # type IoK8sApiCoreV1CSIVolumeSource - -const _property_types_IoK8sApiCoreV1CSIVolumeSource = Dict{Symbol,String}(Symbol("driver")=>"String", Symbol("fsType")=>"String", Symbol("nodePublishSecretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("readOnly")=>"Bool", Symbol("volumeAttributes")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CSIVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CSIVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CSIVolumeSource) - o.driver === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CSIVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Capabilities.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Capabilities.jl deleted file mode 100644 index 50b9d390..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Capabilities.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Capabilities -Adds and removes POSIX capabilities from running containers. - - IoK8sApiCoreV1Capabilities(; - add=nothing, - drop=nothing, - ) - - - add::Vector{String} : Added capabilities - - drop::Vector{String} : Removed capabilities -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Capabilities <: OpenAPI.APIModel - add::Union{Nothing, Vector{String}} = nothing - drop::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1Capabilities(add, drop, ) - OpenAPI.validate_property(IoK8sApiCoreV1Capabilities, Symbol("add"), add) - OpenAPI.validate_property(IoK8sApiCoreV1Capabilities, Symbol("drop"), drop) - return new(add, drop, ) - end -end # type IoK8sApiCoreV1Capabilities - -const _property_types_IoK8sApiCoreV1Capabilities = Dict{Symbol,String}(Symbol("add")=>"Vector{String}", Symbol("drop")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Capabilities }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Capabilities[name]))} - -function check_required(o::IoK8sApiCoreV1Capabilities) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Capabilities }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSPersistentVolumeSource.jl deleted file mode 100644 index 4530fbf6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSPersistentVolumeSource.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CephFSPersistentVolumeSource -Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1CephFSPersistentVolumeSource(; - monitors=nothing, - path=nothing, - readOnly=nothing, - secretFile=nothing, - secretRef=nothing, - user=nothing, - ) - - - monitors::Vector{String} : Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - path::String : Optional: Used as the mounted root, rather than the full Ceph tree, default is / - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - secretFile::String : Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - secretRef::IoK8sApiCoreV1SecretReference - - user::String : Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CephFSPersistentVolumeSource <: OpenAPI.APIModel - monitors::Union{Nothing, Vector{String}} = nothing - path::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretFile::Union{Nothing, String} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - user::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1CephFSPersistentVolumeSource(monitors, path, readOnly, secretFile, secretRef, user, ) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("monitors"), monitors) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("secretFile"), secretFile) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSPersistentVolumeSource, Symbol("user"), user) - return new(monitors, path, readOnly, secretFile, secretRef, user, ) - end -end # type IoK8sApiCoreV1CephFSPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1CephFSPersistentVolumeSource = Dict{Symbol,String}(Symbol("monitors")=>"Vector{String}", Symbol("path")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretFile")=>"String", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CephFSPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CephFSPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CephFSPersistentVolumeSource) - o.monitors === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CephFSPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSVolumeSource.jl deleted file mode 100644 index e6b67143..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CephFSVolumeSource.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CephFSVolumeSource -Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1CephFSVolumeSource(; - monitors=nothing, - path=nothing, - readOnly=nothing, - secretFile=nothing, - secretRef=nothing, - user=nothing, - ) - - - monitors::Vector{String} : Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - path::String : Optional: Used as the mounted root, rather than the full Ceph tree, default is / - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - secretFile::String : Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it - - secretRef::IoK8sApiCoreV1LocalObjectReference - - user::String : Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CephFSVolumeSource <: OpenAPI.APIModel - monitors::Union{Nothing, Vector{String}} = nothing - path::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretFile::Union{Nothing, String} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - user::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1CephFSVolumeSource(monitors, path, readOnly, secretFile, secretRef, user, ) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("monitors"), monitors) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("secretFile"), secretFile) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CephFSVolumeSource, Symbol("user"), user) - return new(monitors, path, readOnly, secretFile, secretRef, user, ) - end -end # type IoK8sApiCoreV1CephFSVolumeSource - -const _property_types_IoK8sApiCoreV1CephFSVolumeSource = Dict{Symbol,String}(Symbol("monitors")=>"Vector{String}", Symbol("path")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretFile")=>"String", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CephFSVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CephFSVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CephFSVolumeSource) - o.monitors === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CephFSVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderPersistentVolumeSource.jl deleted file mode 100644 index 1bc67cc7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderPersistentVolumeSource.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CinderPersistentVolumeSource -Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1CinderPersistentVolumeSource(; - fsType=nothing, - readOnly=nothing, - secretRef=nothing, - volumeID=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md - - secretRef::IoK8sApiCoreV1SecretReference - - volumeID::String : volume id used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CinderPersistentVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - volumeID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1CinderPersistentVolumeSource(fsType, readOnly, secretRef, volumeID, ) - OpenAPI.validate_property(IoK8sApiCoreV1CinderPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1CinderPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CinderPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CinderPersistentVolumeSource, Symbol("volumeID"), volumeID) - return new(fsType, readOnly, secretRef, volumeID, ) - end -end # type IoK8sApiCoreV1CinderPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1CinderPersistentVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("volumeID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CinderPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CinderPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CinderPersistentVolumeSource) - o.volumeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CinderPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderVolumeSource.jl deleted file mode 100644 index 4340a91b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1CinderVolumeSource.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.CinderVolumeSource -Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1CinderVolumeSource(; - fsType=nothing, - readOnly=nothing, - secretRef=nothing, - volumeID=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md - - secretRef::IoK8sApiCoreV1LocalObjectReference - - volumeID::String : volume id used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md -""" -Base.@kwdef mutable struct IoK8sApiCoreV1CinderVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - volumeID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1CinderVolumeSource(fsType, readOnly, secretRef, volumeID, ) - OpenAPI.validate_property(IoK8sApiCoreV1CinderVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1CinderVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1CinderVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1CinderVolumeSource, Symbol("volumeID"), volumeID) - return new(fsType, readOnly, secretRef, volumeID, ) - end -end # type IoK8sApiCoreV1CinderVolumeSource - -const _property_types_IoK8sApiCoreV1CinderVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("volumeID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1CinderVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1CinderVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1CinderVolumeSource) - o.volumeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1CinderVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ClientIPConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ClientIPConfig.jl deleted file mode 100644 index f7522d2a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ClientIPConfig.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ClientIPConfig -ClientIPConfig represents the configurations of Client IP based session affinity. - - IoK8sApiCoreV1ClientIPConfig(; - timeoutSeconds=nothing, - ) - - - timeoutSeconds::Int64 : timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \"ClientIP\". Default value is 10800(for 3 hours). -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ClientIPConfig <: OpenAPI.APIModel - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1ClientIPConfig(timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiCoreV1ClientIPConfig, Symbol("timeoutSeconds"), timeoutSeconds) - return new(timeoutSeconds, ) - end -end # type IoK8sApiCoreV1ClientIPConfig - -const _property_types_IoK8sApiCoreV1ClientIPConfig = Dict{Symbol,String}(Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ClientIPConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ClientIPConfig[name]))} - -function check_required(o::IoK8sApiCoreV1ClientIPConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ClientIPConfig }, name::Symbol, val) - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ClientIPConfig", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentCondition.jl deleted file mode 100644 index 7aa3fa01..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentCondition.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ComponentCondition -Information about the condition of a component. - - IoK8sApiCoreV1ComponentCondition(; - error=nothing, - message=nothing, - status=nothing, - type=nothing, - ) - - - error::String : Condition error code for a component. For example, a health check error code. - - message::String : Message about the condition for a component. For example, information about a health check. - - status::String : Status of the condition for a component. Valid values for \"Healthy\": \"True\", \"False\", or \"Unknown\". - - type::String : Type of condition for a component. Valid value: \"Healthy\" -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ComponentCondition <: OpenAPI.APIModel - error::Union{Nothing, String} = nothing - message::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ComponentCondition(error, message, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentCondition, Symbol("error"), error) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentCondition, Symbol("type"), type) - return new(error, message, status, type, ) - end -end # type IoK8sApiCoreV1ComponentCondition - -const _property_types_IoK8sApiCoreV1ComponentCondition = Dict{Symbol,String}(Symbol("error")=>"String", Symbol("message")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ComponentCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ComponentCondition[name]))} - -function check_required(o::IoK8sApiCoreV1ComponentCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ComponentCondition }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatus.jl deleted file mode 100644 index 42a7af6f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ComponentStatus -ComponentStatus (and ComponentStatusList) holds the cluster validation info. - - IoK8sApiCoreV1ComponentStatus(; - apiVersion=nothing, - conditions=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - conditions::Vector{IoK8sApiCoreV1ComponentCondition} : List of component conditions observed - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ComponentStatus <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ComponentCondition} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - - function IoK8sApiCoreV1ComponentStatus(apiVersion, conditions, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatus, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatus, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatus, Symbol("metadata"), metadata) - return new(apiVersion, conditions, kind, metadata, ) - end -end # type IoK8sApiCoreV1ComponentStatus - -const _property_types_IoK8sApiCoreV1ComponentStatus = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("conditions")=>"Vector{IoK8sApiCoreV1ComponentCondition}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ComponentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ComponentStatus[name]))} - -function check_required(o::IoK8sApiCoreV1ComponentStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ComponentStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatusList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatusList.jl deleted file mode 100644 index 1c955022..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ComponentStatusList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ComponentStatusList -Status of all the conditions for the component as a list of ComponentStatus objects. - - IoK8sApiCoreV1ComponentStatusList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1ComponentStatus} : List of ComponentStatus objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ComponentStatusList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ComponentStatus} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ComponentStatusList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatusList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatusList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatusList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ComponentStatusList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ComponentStatusList - -const _property_types_IoK8sApiCoreV1ComponentStatusList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1ComponentStatus}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ComponentStatusList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ComponentStatusList[name]))} - -function check_required(o::IoK8sApiCoreV1ComponentStatusList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ComponentStatusList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMap.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMap.jl deleted file mode 100644 index 528a9fe2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMap.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMap -ConfigMap holds configuration data for pods to consume. - - IoK8sApiCoreV1ConfigMap(; - apiVersion=nothing, - binaryData=nothing, - data=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - binaryData::Dict{String, Vector{UInt8}} : BinaryData contains the binary data. Each key must consist of alphanumeric characters, '-', '_' or '.'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet. - - data::Dict{String, String} : Data contains the configuration data. Each key must consist of alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMap <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - binaryData::Union{Nothing, Dict{String, Vector{UInt8}}} = nothing - data::Union{Nothing, Dict{String, String}} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - - function IoK8sApiCoreV1ConfigMap(apiVersion, binaryData, data, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMap, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMap, Symbol("binaryData"), binaryData) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMap, Symbol("data"), data) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMap, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMap, Symbol("metadata"), metadata) - return new(apiVersion, binaryData, data, kind, metadata, ) - end -end # type IoK8sApiCoreV1ConfigMap - -const _property_types_IoK8sApiCoreV1ConfigMap = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("binaryData")=>"Dict{String, Vector{UInt8}}", Symbol("data")=>"Dict{String, String}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMap }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMap[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMap) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMap }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapEnvSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapEnvSource.jl deleted file mode 100644 index 3b381be0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapEnvSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapEnvSource -ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. The contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables. - - IoK8sApiCoreV1ConfigMapEnvSource(; - name=nothing, - optional=nothing, - ) - - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the ConfigMap must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapEnvSource <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1ConfigMapEnvSource(name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapEnvSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapEnvSource, Symbol("optional"), optional) - return new(name, optional, ) - end -end # type IoK8sApiCoreV1ConfigMapEnvSource - -const _property_types_IoK8sApiCoreV1ConfigMapEnvSource = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapEnvSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapEnvSource[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapEnvSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapEnvSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapKeySelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapKeySelector.jl deleted file mode 100644 index 2381553a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapKeySelector.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapKeySelector -Selects a key from a ConfigMap. - - IoK8sApiCoreV1ConfigMapKeySelector(; - key=nothing, - name=nothing, - optional=nothing, - ) - - - key::String : The key to select. - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the ConfigMap or its key must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapKeySelector <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1ConfigMapKeySelector(key, name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapKeySelector, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapKeySelector, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapKeySelector, Symbol("optional"), optional) - return new(key, name, optional, ) - end -end # type IoK8sApiCoreV1ConfigMapKeySelector - -const _property_types_IoK8sApiCoreV1ConfigMapKeySelector = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapKeySelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapKeySelector[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapKeySelector) - o.key === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapKeySelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapList.jl deleted file mode 100644 index b89b0fad..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapList -ConfigMapList is a resource containing a list of ConfigMap objects. - - IoK8sApiCoreV1ConfigMapList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1ConfigMap} : Items is the list of ConfigMaps. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ConfigMap} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ConfigMapList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ConfigMapList - -const _property_types_IoK8sApiCoreV1ConfigMapList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1ConfigMap}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapList[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapNodeConfigSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapNodeConfigSource.jl deleted file mode 100644 index de7bd01b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapNodeConfigSource.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapNodeConfigSource -ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. - - IoK8sApiCoreV1ConfigMapNodeConfigSource(; - kubeletConfigKey=nothing, - name=nothing, - namespace=nothing, - resourceVersion=nothing, - uid=nothing, - ) - - - kubeletConfigKey::String : KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases. - - name::String : Name is the metadata.name of the referenced ConfigMap. This field is required in all cases. - - namespace::String : Namespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases. - - resourceVersion::String : ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. - - uid::String : UID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapNodeConfigSource <: OpenAPI.APIModel - kubeletConfigKey::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - resourceVersion::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ConfigMapNodeConfigSource(kubeletConfigKey, name, namespace, resourceVersion, uid, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapNodeConfigSource, Symbol("kubeletConfigKey"), kubeletConfigKey) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapNodeConfigSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapNodeConfigSource, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapNodeConfigSource, Symbol("resourceVersion"), resourceVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapNodeConfigSource, Symbol("uid"), uid) - return new(kubeletConfigKey, name, namespace, resourceVersion, uid, ) - end -end # type IoK8sApiCoreV1ConfigMapNodeConfigSource - -const _property_types_IoK8sApiCoreV1ConfigMapNodeConfigSource = Dict{Symbol,String}(Symbol("kubeletConfigKey")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("resourceVersion")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapNodeConfigSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapNodeConfigSource[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapNodeConfigSource) - o.kubeletConfigKey === nothing && (return false) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapNodeConfigSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapProjection.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapProjection.jl deleted file mode 100644 index efe20dd5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapProjection.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapProjection -Adapts a ConfigMap into a projected volume. The contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode. - - IoK8sApiCoreV1ConfigMapProjection(; - items=nothing, - name=nothing, - optional=nothing, - ) - - - items::Vector{IoK8sApiCoreV1KeyToPath} : If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the ConfigMap or its keys must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapProjection <: OpenAPI.APIModel - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1KeyToPath} } - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1ConfigMapProjection(items, name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapProjection, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapProjection, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapProjection, Symbol("optional"), optional) - return new(items, name, optional, ) - end -end # type IoK8sApiCoreV1ConfigMapProjection - -const _property_types_IoK8sApiCoreV1ConfigMapProjection = Dict{Symbol,String}(Symbol("items")=>"Vector{IoK8sApiCoreV1KeyToPath}", Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapProjection }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapProjection[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapProjection) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapProjection }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapVolumeSource.jl deleted file mode 100644 index e4af2a61..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ConfigMapVolumeSource.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ConfigMapVolumeSource -Adapts a ConfigMap into a volume. The contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1ConfigMapVolumeSource(; - defaultMode=nothing, - items=nothing, - name=nothing, - optional=nothing, - ) - - - defaultMode::Int64 : Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - items::Vector{IoK8sApiCoreV1KeyToPath} : If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the ConfigMap or its keys must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ConfigMapVolumeSource <: OpenAPI.APIModel - defaultMode::Union{Nothing, Int64} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1KeyToPath} } - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1ConfigMapVolumeSource(defaultMode, items, name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapVolumeSource, Symbol("defaultMode"), defaultMode) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapVolumeSource, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapVolumeSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ConfigMapVolumeSource, Symbol("optional"), optional) - return new(defaultMode, items, name, optional, ) - end -end # type IoK8sApiCoreV1ConfigMapVolumeSource - -const _property_types_IoK8sApiCoreV1ConfigMapVolumeSource = Dict{Symbol,String}(Symbol("defaultMode")=>"Int64", Symbol("items")=>"Vector{IoK8sApiCoreV1KeyToPath}", Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ConfigMapVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ConfigMapVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ConfigMapVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ConfigMapVolumeSource }, name::Symbol, val) - if name === Symbol("defaultMode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ConfigMapVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Container.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Container.jl deleted file mode 100644 index f63e7a72..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Container.jl +++ /dev/null @@ -1,116 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Container -A single application container that you want to run within a pod. - - IoK8sApiCoreV1Container(; - args=nothing, - command=nothing, - env=nothing, - envFrom=nothing, - image=nothing, - imagePullPolicy=nothing, - lifecycle=nothing, - livenessProbe=nothing, - name=nothing, - ports=nothing, - readinessProbe=nothing, - resources=nothing, - securityContext=nothing, - startupProbe=nothing, - stdin=nothing, - stdinOnce=nothing, - terminationMessagePath=nothing, - terminationMessagePolicy=nothing, - tty=nothing, - volumeDevices=nothing, - volumeMounts=nothing, - workingDir=nothing, - ) - - - args::Vector{String} : Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell - - command::Vector{String} : Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell - - env::Vector{IoK8sApiCoreV1EnvVar} : List of environment variables to set in the container. Cannot be updated. - - envFrom::Vector{IoK8sApiCoreV1EnvFromSource} : List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. - - image::String : Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. - - imagePullPolicy::String : Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images - - lifecycle::IoK8sApiCoreV1Lifecycle - - livenessProbe::IoK8sApiCoreV1Probe - - name::String : Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. - - ports::Vector{IoK8sApiCoreV1ContainerPort} : List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated. - - readinessProbe::IoK8sApiCoreV1Probe - - resources::IoK8sApiCoreV1ResourceRequirements - - securityContext::IoK8sApiCoreV1SecurityContext - - startupProbe::IoK8sApiCoreV1Probe - - stdin::Bool : Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. - - stdinOnce::Bool : Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false - - terminationMessagePath::String : Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. - - terminationMessagePolicy::String : Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. - - tty::Bool : Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. - - volumeDevices::Vector{IoK8sApiCoreV1VolumeDevice} : volumeDevices is the list of block devices to be used by the container. This is a beta feature. - - volumeMounts::Vector{IoK8sApiCoreV1VolumeMount} : Pod volumes to mount into the container's filesystem. Cannot be updated. - - workingDir::String : Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Container <: OpenAPI.APIModel - args::Union{Nothing, Vector{String}} = nothing - command::Union{Nothing, Vector{String}} = nothing - env::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvVar} } - envFrom::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvFromSource} } - image::Union{Nothing, String} = nothing - imagePullPolicy::Union{Nothing, String} = nothing - lifecycle = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Lifecycle } - livenessProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - name::Union{Nothing, String} = nothing - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerPort} } - readinessProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - resources = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceRequirements } - securityContext = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecurityContext } - startupProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - stdin::Union{Nothing, Bool} = nothing - stdinOnce::Union{Nothing, Bool} = nothing - terminationMessagePath::Union{Nothing, String} = nothing - terminationMessagePolicy::Union{Nothing, String} = nothing - tty::Union{Nothing, Bool} = nothing - volumeDevices::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeDevice} } - volumeMounts::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeMount} } - workingDir::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Container(args, command, env, envFrom, image, imagePullPolicy, lifecycle, livenessProbe, name, ports, readinessProbe, resources, securityContext, startupProbe, stdin, stdinOnce, terminationMessagePath, terminationMessagePolicy, tty, volumeDevices, volumeMounts, workingDir, ) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("args"), args) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("command"), command) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("env"), env) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("envFrom"), envFrom) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("image"), image) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("imagePullPolicy"), imagePullPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("lifecycle"), lifecycle) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("livenessProbe"), livenessProbe) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("ports"), ports) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("readinessProbe"), readinessProbe) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("securityContext"), securityContext) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("startupProbe"), startupProbe) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("stdin"), stdin) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("stdinOnce"), stdinOnce) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("terminationMessagePath"), terminationMessagePath) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("terminationMessagePolicy"), terminationMessagePolicy) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("tty"), tty) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("volumeDevices"), volumeDevices) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("volumeMounts"), volumeMounts) - OpenAPI.validate_property(IoK8sApiCoreV1Container, Symbol("workingDir"), workingDir) - return new(args, command, env, envFrom, image, imagePullPolicy, lifecycle, livenessProbe, name, ports, readinessProbe, resources, securityContext, startupProbe, stdin, stdinOnce, terminationMessagePath, terminationMessagePolicy, tty, volumeDevices, volumeMounts, workingDir, ) - end -end # type IoK8sApiCoreV1Container - -const _property_types_IoK8sApiCoreV1Container = Dict{Symbol,String}(Symbol("args")=>"Vector{String}", Symbol("command")=>"Vector{String}", Symbol("env")=>"Vector{IoK8sApiCoreV1EnvVar}", Symbol("envFrom")=>"Vector{IoK8sApiCoreV1EnvFromSource}", Symbol("image")=>"String", Symbol("imagePullPolicy")=>"String", Symbol("lifecycle")=>"IoK8sApiCoreV1Lifecycle", Symbol("livenessProbe")=>"IoK8sApiCoreV1Probe", Symbol("name")=>"String", Symbol("ports")=>"Vector{IoK8sApiCoreV1ContainerPort}", Symbol("readinessProbe")=>"IoK8sApiCoreV1Probe", Symbol("resources")=>"IoK8sApiCoreV1ResourceRequirements", Symbol("securityContext")=>"IoK8sApiCoreV1SecurityContext", Symbol("startupProbe")=>"IoK8sApiCoreV1Probe", Symbol("stdin")=>"Bool", Symbol("stdinOnce")=>"Bool", Symbol("terminationMessagePath")=>"String", Symbol("terminationMessagePolicy")=>"String", Symbol("tty")=>"Bool", Symbol("volumeDevices")=>"Vector{IoK8sApiCoreV1VolumeDevice}", Symbol("volumeMounts")=>"Vector{IoK8sApiCoreV1VolumeMount}", Symbol("workingDir")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Container }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Container[name]))} - -function check_required(o::IoK8sApiCoreV1Container) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Container }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerImage.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerImage.jl deleted file mode 100644 index c87e5bc1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerImage.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerImage -Describe a container image - - IoK8sApiCoreV1ContainerImage(; - names=nothing, - sizeBytes=nothing, - ) - - - names::Vector{String} : Names by which this image is known. e.g. [\"k8s.gcr.io/hyperkube:v1.0.7\", \"dockerhub.io/google_containers/hyperkube:v1.0.7\"] - - sizeBytes::Int64 : The size of the image in bytes. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerImage <: OpenAPI.APIModel - names::Union{Nothing, Vector{String}} = nothing - sizeBytes::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1ContainerImage(names, sizeBytes, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerImage, Symbol("names"), names) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerImage, Symbol("sizeBytes"), sizeBytes) - return new(names, sizeBytes, ) - end -end # type IoK8sApiCoreV1ContainerImage - -const _property_types_IoK8sApiCoreV1ContainerImage = Dict{Symbol,String}(Symbol("names")=>"Vector{String}", Symbol("sizeBytes")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerImage }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerImage[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerImage) - o.names === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerImage }, name::Symbol, val) - if name === Symbol("sizeBytes") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerImage", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerPort.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerPort.jl deleted file mode 100644 index 0d5a787e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerPort.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerPort -ContainerPort represents a network port in a single container. - - IoK8sApiCoreV1ContainerPort(; - containerPort=nothing, - hostIP=nothing, - hostPort=nothing, - name=nothing, - protocol=nothing, - ) - - - containerPort::Int64 : Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. - - hostIP::String : What host IP to bind the external port to. - - hostPort::Int64 : Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. - - name::String : If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. - - protocol::String : Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\". -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerPort <: OpenAPI.APIModel - containerPort::Union{Nothing, Int64} = nothing - hostIP::Union{Nothing, String} = nothing - hostPort::Union{Nothing, Int64} = nothing - name::Union{Nothing, String} = nothing - protocol::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ContainerPort(containerPort, hostIP, hostPort, name, protocol, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerPort, Symbol("containerPort"), containerPort) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerPort, Symbol("hostIP"), hostIP) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerPort, Symbol("hostPort"), hostPort) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerPort, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerPort, Symbol("protocol"), protocol) - return new(containerPort, hostIP, hostPort, name, protocol, ) - end -end # type IoK8sApiCoreV1ContainerPort - -const _property_types_IoK8sApiCoreV1ContainerPort = Dict{Symbol,String}(Symbol("containerPort")=>"Int64", Symbol("hostIP")=>"String", Symbol("hostPort")=>"Int64", Symbol("name")=>"String", Symbol("protocol")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerPort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerPort[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerPort) - o.containerPort === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerPort }, name::Symbol, val) - if name === Symbol("containerPort") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerPort", :format, val, "int32") - end - if name === Symbol("hostPort") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerPort", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerState.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerState.jl deleted file mode 100644 index 94dbb927..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerState.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerState -ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting. - - IoK8sApiCoreV1ContainerState(; - running=nothing, - terminated=nothing, - waiting=nothing, - ) - - - running::IoK8sApiCoreV1ContainerStateRunning - - terminated::IoK8sApiCoreV1ContainerStateTerminated - - waiting::IoK8sApiCoreV1ContainerStateWaiting -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerState <: OpenAPI.APIModel - running = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ContainerStateRunning } - terminated = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ContainerStateTerminated } - waiting = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ContainerStateWaiting } - - function IoK8sApiCoreV1ContainerState(running, terminated, waiting, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerState, Symbol("running"), running) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerState, Symbol("terminated"), terminated) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerState, Symbol("waiting"), waiting) - return new(running, terminated, waiting, ) - end -end # type IoK8sApiCoreV1ContainerState - -const _property_types_IoK8sApiCoreV1ContainerState = Dict{Symbol,String}(Symbol("running")=>"IoK8sApiCoreV1ContainerStateRunning", Symbol("terminated")=>"IoK8sApiCoreV1ContainerStateTerminated", Symbol("waiting")=>"IoK8sApiCoreV1ContainerStateWaiting", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerState }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerState[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerState) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerState }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateRunning.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateRunning.jl deleted file mode 100644 index 3b0f8212..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateRunning.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerStateRunning -ContainerStateRunning is a running state of a container. - - IoK8sApiCoreV1ContainerStateRunning(; - startedAt=nothing, - ) - - - startedAt::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerStateRunning <: OpenAPI.APIModel - startedAt::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiCoreV1ContainerStateRunning(startedAt, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateRunning, Symbol("startedAt"), startedAt) - return new(startedAt, ) - end -end # type IoK8sApiCoreV1ContainerStateRunning - -const _property_types_IoK8sApiCoreV1ContainerStateRunning = Dict{Symbol,String}(Symbol("startedAt")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerStateRunning }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerStateRunning[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerStateRunning) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerStateRunning }, name::Symbol, val) - if name === Symbol("startedAt") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStateRunning", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateTerminated.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateTerminated.jl deleted file mode 100644 index fd1cf0c8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateTerminated.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerStateTerminated -ContainerStateTerminated is a terminated state of a container. - - IoK8sApiCoreV1ContainerStateTerminated(; - containerID=nothing, - exitCode=nothing, - finishedAt=nothing, - message=nothing, - reason=nothing, - signal=nothing, - startedAt=nothing, - ) - - - containerID::String : Container's ID in the format 'docker://<container_id>' - - exitCode::Int64 : Exit status from the last termination of the container - - finishedAt::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Message regarding the last termination of the container - - reason::String : (brief) reason from the last termination of the container - - signal::Int64 : Signal from the last termination of the container - - startedAt::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerStateTerminated <: OpenAPI.APIModel - containerID::Union{Nothing, String} = nothing - exitCode::Union{Nothing, Int64} = nothing - finishedAt::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - signal::Union{Nothing, Int64} = nothing - startedAt::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiCoreV1ContainerStateTerminated(containerID, exitCode, finishedAt, message, reason, signal, startedAt, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("containerID"), containerID) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("exitCode"), exitCode) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("finishedAt"), finishedAt) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("signal"), signal) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateTerminated, Symbol("startedAt"), startedAt) - return new(containerID, exitCode, finishedAt, message, reason, signal, startedAt, ) - end -end # type IoK8sApiCoreV1ContainerStateTerminated - -const _property_types_IoK8sApiCoreV1ContainerStateTerminated = Dict{Symbol,String}(Symbol("containerID")=>"String", Symbol("exitCode")=>"Int64", Symbol("finishedAt")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("signal")=>"Int64", Symbol("startedAt")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerStateTerminated }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerStateTerminated[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerStateTerminated) - o.exitCode === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerStateTerminated }, name::Symbol, val) - if name === Symbol("exitCode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStateTerminated", :format, val, "int32") - end - if name === Symbol("finishedAt") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStateTerminated", :format, val, "date-time") - end - if name === Symbol("signal") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStateTerminated", :format, val, "int32") - end - if name === Symbol("startedAt") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStateTerminated", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateWaiting.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateWaiting.jl deleted file mode 100644 index 2c69459c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStateWaiting.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerStateWaiting -ContainerStateWaiting is a waiting state of a container. - - IoK8sApiCoreV1ContainerStateWaiting(; - message=nothing, - reason=nothing, - ) - - - message::String : Message regarding why the container is not yet running. - - reason::String : (brief) reason the container is not yet running. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerStateWaiting <: OpenAPI.APIModel - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ContainerStateWaiting(message, reason, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateWaiting, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStateWaiting, Symbol("reason"), reason) - return new(message, reason, ) - end -end # type IoK8sApiCoreV1ContainerStateWaiting - -const _property_types_IoK8sApiCoreV1ContainerStateWaiting = Dict{Symbol,String}(Symbol("message")=>"String", Symbol("reason")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerStateWaiting }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerStateWaiting[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerStateWaiting) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerStateWaiting }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStatus.jl deleted file mode 100644 index 02713ea8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ContainerStatus.jl +++ /dev/null @@ -1,71 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ContainerStatus -ContainerStatus contains details for the current status of this container. - - IoK8sApiCoreV1ContainerStatus(; - containerID=nothing, - image=nothing, - imageID=nothing, - lastState=nothing, - name=nothing, - ready=nothing, - restartCount=nothing, - started=nothing, - state=nothing, - ) - - - containerID::String : Container's ID in the format 'docker://<container_id>'. - - image::String : The image the container is running. More info: https://kubernetes.io/docs/concepts/containers/images - - imageID::String : ImageID of the container's image. - - lastState::IoK8sApiCoreV1ContainerState - - name::String : This must be a DNS_LABEL. Each container in a pod must have a unique name. Cannot be updated. - - ready::Bool : Specifies whether the container has passed its readiness probe. - - restartCount::Int64 : The number of times the container has been restarted, currently based on the number of dead containers that have not yet been removed. Note that this is calculated from dead containers. But those containers are subject to garbage collection. This value will get capped at 5 by GC. - - started::Bool : Specifies whether the container has passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. Is always true when no startupProbe is defined. - - state::IoK8sApiCoreV1ContainerState -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ContainerStatus <: OpenAPI.APIModel - containerID::Union{Nothing, String} = nothing - image::Union{Nothing, String} = nothing - imageID::Union{Nothing, String} = nothing - lastState = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ContainerState } - name::Union{Nothing, String} = nothing - ready::Union{Nothing, Bool} = nothing - restartCount::Union{Nothing, Int64} = nothing - started::Union{Nothing, Bool} = nothing - state = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ContainerState } - - function IoK8sApiCoreV1ContainerStatus(containerID, image, imageID, lastState, name, ready, restartCount, started, state, ) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("containerID"), containerID) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("image"), image) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("imageID"), imageID) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("lastState"), lastState) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("ready"), ready) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("restartCount"), restartCount) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("started"), started) - OpenAPI.validate_property(IoK8sApiCoreV1ContainerStatus, Symbol("state"), state) - return new(containerID, image, imageID, lastState, name, ready, restartCount, started, state, ) - end -end # type IoK8sApiCoreV1ContainerStatus - -const _property_types_IoK8sApiCoreV1ContainerStatus = Dict{Symbol,String}(Symbol("containerID")=>"String", Symbol("image")=>"String", Symbol("imageID")=>"String", Symbol("lastState")=>"IoK8sApiCoreV1ContainerState", Symbol("name")=>"String", Symbol("ready")=>"Bool", Symbol("restartCount")=>"Int64", Symbol("started")=>"Bool", Symbol("state")=>"IoK8sApiCoreV1ContainerState", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ContainerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ContainerStatus[name]))} - -function check_required(o::IoK8sApiCoreV1ContainerStatus) - o.image === nothing && (return false) - o.imageID === nothing && (return false) - o.name === nothing && (return false) - o.ready === nothing && (return false) - o.restartCount === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ContainerStatus }, name::Symbol, val) - if name === Symbol("restartCount") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ContainerStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DaemonEndpoint.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1DaemonEndpoint.jl deleted file mode 100644 index edf69804..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DaemonEndpoint.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.DaemonEndpoint -DaemonEndpoint contains information about a single Daemon endpoint. - - IoK8sApiCoreV1DaemonEndpoint(; - Port=nothing, - ) - - - Port::Int64 : Port number of the given endpoint. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1DaemonEndpoint <: OpenAPI.APIModel - Port::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1DaemonEndpoint(Port, ) - OpenAPI.validate_property(IoK8sApiCoreV1DaemonEndpoint, Symbol("Port"), Port) - return new(Port, ) - end -end # type IoK8sApiCoreV1DaemonEndpoint - -const _property_types_IoK8sApiCoreV1DaemonEndpoint = Dict{Symbol,String}(Symbol("Port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1DaemonEndpoint }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1DaemonEndpoint[name]))} - -function check_required(o::IoK8sApiCoreV1DaemonEndpoint) - o.Port === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1DaemonEndpoint }, name::Symbol, val) - if name === Symbol("Port") - OpenAPI.validate_param(name, "IoK8sApiCoreV1DaemonEndpoint", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIProjection.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIProjection.jl deleted file mode 100644 index ac85c446..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIProjection.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.DownwardAPIProjection -Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode. - - IoK8sApiCoreV1DownwardAPIProjection(; - items=nothing, - ) - - - items::Vector{IoK8sApiCoreV1DownwardAPIVolumeFile} : Items is a list of DownwardAPIVolume file -""" -Base.@kwdef mutable struct IoK8sApiCoreV1DownwardAPIProjection <: OpenAPI.APIModel - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1DownwardAPIVolumeFile} } - - function IoK8sApiCoreV1DownwardAPIProjection(items, ) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIProjection, Symbol("items"), items) - return new(items, ) - end -end # type IoK8sApiCoreV1DownwardAPIProjection - -const _property_types_IoK8sApiCoreV1DownwardAPIProjection = Dict{Symbol,String}(Symbol("items")=>"Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1DownwardAPIProjection }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1DownwardAPIProjection[name]))} - -function check_required(o::IoK8sApiCoreV1DownwardAPIProjection) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1DownwardAPIProjection }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeFile.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeFile.jl deleted file mode 100644 index af4b67d1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeFile.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.DownwardAPIVolumeFile -DownwardAPIVolumeFile represents information to create the file containing the pod field - - IoK8sApiCoreV1DownwardAPIVolumeFile(; - fieldRef=nothing, - mode=nothing, - path=nothing, - resourceFieldRef=nothing, - ) - - - fieldRef::IoK8sApiCoreV1ObjectFieldSelector - - mode::Int64 : Optional: mode bits to use on this file, must be a value between 0 and 0777. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - path::String : Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..' - - resourceFieldRef::IoK8sApiCoreV1ResourceFieldSelector -""" -Base.@kwdef mutable struct IoK8sApiCoreV1DownwardAPIVolumeFile <: OpenAPI.APIModel - fieldRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectFieldSelector } - mode::Union{Nothing, Int64} = nothing - path::Union{Nothing, String} = nothing - resourceFieldRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceFieldSelector } - - function IoK8sApiCoreV1DownwardAPIVolumeFile(fieldRef, mode, path, resourceFieldRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeFile, Symbol("fieldRef"), fieldRef) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeFile, Symbol("mode"), mode) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeFile, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeFile, Symbol("resourceFieldRef"), resourceFieldRef) - return new(fieldRef, mode, path, resourceFieldRef, ) - end -end # type IoK8sApiCoreV1DownwardAPIVolumeFile - -const _property_types_IoK8sApiCoreV1DownwardAPIVolumeFile = Dict{Symbol,String}(Symbol("fieldRef")=>"IoK8sApiCoreV1ObjectFieldSelector", Symbol("mode")=>"Int64", Symbol("path")=>"String", Symbol("resourceFieldRef")=>"IoK8sApiCoreV1ResourceFieldSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1DownwardAPIVolumeFile }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1DownwardAPIVolumeFile[name]))} - -function check_required(o::IoK8sApiCoreV1DownwardAPIVolumeFile) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1DownwardAPIVolumeFile }, name::Symbol, val) - if name === Symbol("mode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1DownwardAPIVolumeFile", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeSource.jl deleted file mode 100644 index d395279b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1DownwardAPIVolumeSource.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.DownwardAPIVolumeSource -DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1DownwardAPIVolumeSource(; - defaultMode=nothing, - items=nothing, - ) - - - defaultMode::Int64 : Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - items::Vector{IoK8sApiCoreV1DownwardAPIVolumeFile} : Items is a list of downward API volume file -""" -Base.@kwdef mutable struct IoK8sApiCoreV1DownwardAPIVolumeSource <: OpenAPI.APIModel - defaultMode::Union{Nothing, Int64} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1DownwardAPIVolumeFile} } - - function IoK8sApiCoreV1DownwardAPIVolumeSource(defaultMode, items, ) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeSource, Symbol("defaultMode"), defaultMode) - OpenAPI.validate_property(IoK8sApiCoreV1DownwardAPIVolumeSource, Symbol("items"), items) - return new(defaultMode, items, ) - end -end # type IoK8sApiCoreV1DownwardAPIVolumeSource - -const _property_types_IoK8sApiCoreV1DownwardAPIVolumeSource = Dict{Symbol,String}(Symbol("defaultMode")=>"Int64", Symbol("items")=>"Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1DownwardAPIVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1DownwardAPIVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1DownwardAPIVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1DownwardAPIVolumeSource }, name::Symbol, val) - if name === Symbol("defaultMode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1DownwardAPIVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EmptyDirVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EmptyDirVolumeSource.jl deleted file mode 100644 index 2e2a31c5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EmptyDirVolumeSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EmptyDirVolumeSource -Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1EmptyDirVolumeSource(; - medium=nothing, - sizeLimit=nothing, - ) - - - medium::String : What type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir - - sizeLimit::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EmptyDirVolumeSource <: OpenAPI.APIModel - medium::Union{Nothing, String} = nothing - sizeLimit::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1EmptyDirVolumeSource(medium, sizeLimit, ) - OpenAPI.validate_property(IoK8sApiCoreV1EmptyDirVolumeSource, Symbol("medium"), medium) - OpenAPI.validate_property(IoK8sApiCoreV1EmptyDirVolumeSource, Symbol("sizeLimit"), sizeLimit) - return new(medium, sizeLimit, ) - end -end # type IoK8sApiCoreV1EmptyDirVolumeSource - -const _property_types_IoK8sApiCoreV1EmptyDirVolumeSource = Dict{Symbol,String}(Symbol("medium")=>"String", Symbol("sizeLimit")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EmptyDirVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EmptyDirVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1EmptyDirVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EmptyDirVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointAddress.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointAddress.jl deleted file mode 100644 index 53c0e65f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointAddress.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EndpointAddress -EndpointAddress is a tuple that describes single IP address. - - IoK8sApiCoreV1EndpointAddress(; - hostname=nothing, - ip=nothing, - nodeName=nothing, - targetRef=nothing, - ) - - - hostname::String : The Hostname of this endpoint - - ip::String : The IP of this endpoint. May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24). IPv6 is also accepted but not fully supported on all platforms. Also, certain kubernetes components, like kube-proxy, are not IPv6 ready. - - nodeName::String : Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node. - - targetRef::IoK8sApiCoreV1ObjectReference -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EndpointAddress <: OpenAPI.APIModel - hostname::Union{Nothing, String} = nothing - ip::Union{Nothing, String} = nothing - nodeName::Union{Nothing, String} = nothing - targetRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - - function IoK8sApiCoreV1EndpointAddress(hostname, ip, nodeName, targetRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointAddress, Symbol("hostname"), hostname) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointAddress, Symbol("ip"), ip) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointAddress, Symbol("nodeName"), nodeName) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointAddress, Symbol("targetRef"), targetRef) - return new(hostname, ip, nodeName, targetRef, ) - end -end # type IoK8sApiCoreV1EndpointAddress - -const _property_types_IoK8sApiCoreV1EndpointAddress = Dict{Symbol,String}(Symbol("hostname")=>"String", Symbol("ip")=>"String", Symbol("nodeName")=>"String", Symbol("targetRef")=>"IoK8sApiCoreV1ObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EndpointAddress }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EndpointAddress[name]))} - -function check_required(o::IoK8sApiCoreV1EndpointAddress) - o.ip === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EndpointAddress }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointPort.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointPort.jl deleted file mode 100644 index 5c03cae6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointPort.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EndpointPort -EndpointPort is a tuple that describes a single port. - - IoK8sApiCoreV1EndpointPort(; - name=nothing, - port=nothing, - protocol=nothing, - ) - - - name::String : The name of this port. This must match the 'name' field in the corresponding ServicePort. Must be a DNS_LABEL. Optional only if one port is defined. - - port::Int64 : The port number of the endpoint. - - protocol::String : The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EndpointPort <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - protocol::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1EndpointPort(name, port, protocol, ) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointPort, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointPort, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointPort, Symbol("protocol"), protocol) - return new(name, port, protocol, ) - end -end # type IoK8sApiCoreV1EndpointPort - -const _property_types_IoK8sApiCoreV1EndpointPort = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("port")=>"Int64", Symbol("protocol")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EndpointPort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EndpointPort[name]))} - -function check_required(o::IoK8sApiCoreV1EndpointPort) - o.port === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EndpointPort }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiCoreV1EndpointPort", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointSubset.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointSubset.jl deleted file mode 100644 index 23706e95..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointSubset.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EndpointSubset -EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given: { Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}], Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}] } The resulting set of endpoints can be viewed as: a: [ 10.10.1.1:8675, 10.10.2.2:8675 ], b: [ 10.10.1.1:309, 10.10.2.2:309 ] - - IoK8sApiCoreV1EndpointSubset(; - addresses=nothing, - notReadyAddresses=nothing, - ports=nothing, - ) - - - addresses::Vector{IoK8sApiCoreV1EndpointAddress} : IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize. - - notReadyAddresses::Vector{IoK8sApiCoreV1EndpointAddress} : IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check. - - ports::Vector{IoK8sApiCoreV1EndpointPort} : Port numbers available on the related IP addresses. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EndpointSubset <: OpenAPI.APIModel - addresses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EndpointAddress} } - notReadyAddresses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EndpointAddress} } - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EndpointPort} } - - function IoK8sApiCoreV1EndpointSubset(addresses, notReadyAddresses, ports, ) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointSubset, Symbol("addresses"), addresses) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointSubset, Symbol("notReadyAddresses"), notReadyAddresses) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointSubset, Symbol("ports"), ports) - return new(addresses, notReadyAddresses, ports, ) - end -end # type IoK8sApiCoreV1EndpointSubset - -const _property_types_IoK8sApiCoreV1EndpointSubset = Dict{Symbol,String}(Symbol("addresses")=>"Vector{IoK8sApiCoreV1EndpointAddress}", Symbol("notReadyAddresses")=>"Vector{IoK8sApiCoreV1EndpointAddress}", Symbol("ports")=>"Vector{IoK8sApiCoreV1EndpointPort}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EndpointSubset }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EndpointSubset[name]))} - -function check_required(o::IoK8sApiCoreV1EndpointSubset) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EndpointSubset }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Endpoints.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Endpoints.jl deleted file mode 100644 index 043b6665..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Endpoints.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Endpoints -Endpoints is a collection of endpoints that implement the actual service. Example: Name: \"mysvc\", Subsets: [ { Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}], Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}] }, { Addresses: [{\"ip\": \"10.10.3.3\"}], Ports: [{\"name\": \"a\", \"port\": 93}, {\"name\": \"b\", \"port\": 76}] }, ] - - IoK8sApiCoreV1Endpoints(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - subsets=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - subsets::Vector{IoK8sApiCoreV1EndpointSubset} : The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Endpoints <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - subsets::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EndpointSubset} } - - function IoK8sApiCoreV1Endpoints(apiVersion, kind, metadata, subsets, ) - OpenAPI.validate_property(IoK8sApiCoreV1Endpoints, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Endpoints, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Endpoints, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Endpoints, Symbol("subsets"), subsets) - return new(apiVersion, kind, metadata, subsets, ) - end -end # type IoK8sApiCoreV1Endpoints - -const _property_types_IoK8sApiCoreV1Endpoints = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("subsets")=>"Vector{IoK8sApiCoreV1EndpointSubset}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Endpoints }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Endpoints[name]))} - -function check_required(o::IoK8sApiCoreV1Endpoints) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Endpoints }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointsList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointsList.jl deleted file mode 100644 index d4f96756..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EndpointsList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EndpointsList -EndpointsList is a list of endpoints. - - IoK8sApiCoreV1EndpointsList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Endpoints} : List of endpoints. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EndpointsList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Endpoints} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1EndpointsList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointsList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointsList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointsList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1EndpointsList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1EndpointsList - -const _property_types_IoK8sApiCoreV1EndpointsList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Endpoints}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EndpointsList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EndpointsList[name]))} - -function check_required(o::IoK8sApiCoreV1EndpointsList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EndpointsList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvFromSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvFromSource.jl deleted file mode 100644 index 1bcbfdcf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvFromSource.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EnvFromSource -EnvFromSource represents the source of a set of ConfigMaps - - IoK8sApiCoreV1EnvFromSource(; - configMapRef=nothing, - prefix=nothing, - secretRef=nothing, - ) - - - configMapRef::IoK8sApiCoreV1ConfigMapEnvSource - - prefix::String : An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. - - secretRef::IoK8sApiCoreV1SecretEnvSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EnvFromSource <: OpenAPI.APIModel - configMapRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ConfigMapEnvSource } - prefix::Union{Nothing, String} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretEnvSource } - - function IoK8sApiCoreV1EnvFromSource(configMapRef, prefix, secretRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1EnvFromSource, Symbol("configMapRef"), configMapRef) - OpenAPI.validate_property(IoK8sApiCoreV1EnvFromSource, Symbol("prefix"), prefix) - OpenAPI.validate_property(IoK8sApiCoreV1EnvFromSource, Symbol("secretRef"), secretRef) - return new(configMapRef, prefix, secretRef, ) - end -end # type IoK8sApiCoreV1EnvFromSource - -const _property_types_IoK8sApiCoreV1EnvFromSource = Dict{Symbol,String}(Symbol("configMapRef")=>"IoK8sApiCoreV1ConfigMapEnvSource", Symbol("prefix")=>"String", Symbol("secretRef")=>"IoK8sApiCoreV1SecretEnvSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EnvFromSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EnvFromSource[name]))} - -function check_required(o::IoK8sApiCoreV1EnvFromSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EnvFromSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVar.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVar.jl deleted file mode 100644 index e1581da5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVar.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EnvVar -EnvVar represents an environment variable present in a Container. - - IoK8sApiCoreV1EnvVar(; - name=nothing, - value=nothing, - valueFrom=nothing, - ) - - - name::String : Name of the environment variable. Must be a C_IDENTIFIER. - - value::String : Variable references $(VAR_NAME) are expanded using the previous defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\". - - valueFrom::IoK8sApiCoreV1EnvVarSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EnvVar <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - valueFrom = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1EnvVarSource } - - function IoK8sApiCoreV1EnvVar(name, value, valueFrom, ) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVar, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVar, Symbol("value"), value) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVar, Symbol("valueFrom"), valueFrom) - return new(name, value, valueFrom, ) - end -end # type IoK8sApiCoreV1EnvVar - -const _property_types_IoK8sApiCoreV1EnvVar = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("value")=>"String", Symbol("valueFrom")=>"IoK8sApiCoreV1EnvVarSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EnvVar }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EnvVar[name]))} - -function check_required(o::IoK8sApiCoreV1EnvVar) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EnvVar }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVarSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVarSource.jl deleted file mode 100644 index 84196b8d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EnvVarSource.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EnvVarSource -EnvVarSource represents a source for the value of an EnvVar. - - IoK8sApiCoreV1EnvVarSource(; - configMapKeyRef=nothing, - fieldRef=nothing, - resourceFieldRef=nothing, - secretKeyRef=nothing, - ) - - - configMapKeyRef::IoK8sApiCoreV1ConfigMapKeySelector - - fieldRef::IoK8sApiCoreV1ObjectFieldSelector - - resourceFieldRef::IoK8sApiCoreV1ResourceFieldSelector - - secretKeyRef::IoK8sApiCoreV1SecretKeySelector -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EnvVarSource <: OpenAPI.APIModel - configMapKeyRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ConfigMapKeySelector } - fieldRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectFieldSelector } - resourceFieldRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceFieldSelector } - secretKeyRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretKeySelector } - - function IoK8sApiCoreV1EnvVarSource(configMapKeyRef, fieldRef, resourceFieldRef, secretKeyRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVarSource, Symbol("configMapKeyRef"), configMapKeyRef) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVarSource, Symbol("fieldRef"), fieldRef) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVarSource, Symbol("resourceFieldRef"), resourceFieldRef) - OpenAPI.validate_property(IoK8sApiCoreV1EnvVarSource, Symbol("secretKeyRef"), secretKeyRef) - return new(configMapKeyRef, fieldRef, resourceFieldRef, secretKeyRef, ) - end -end # type IoK8sApiCoreV1EnvVarSource - -const _property_types_IoK8sApiCoreV1EnvVarSource = Dict{Symbol,String}(Symbol("configMapKeyRef")=>"IoK8sApiCoreV1ConfigMapKeySelector", Symbol("fieldRef")=>"IoK8sApiCoreV1ObjectFieldSelector", Symbol("resourceFieldRef")=>"IoK8sApiCoreV1ResourceFieldSelector", Symbol("secretKeyRef")=>"IoK8sApiCoreV1SecretKeySelector", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EnvVarSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EnvVarSource[name]))} - -function check_required(o::IoK8sApiCoreV1EnvVarSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EnvVarSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EphemeralContainer.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EphemeralContainer.jl deleted file mode 100644 index a5d165de..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EphemeralContainer.jl +++ /dev/null @@ -1,120 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EphemeralContainer -An EphemeralContainer is a container that may be added temporarily to an existing pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a pod is removed or restarted. If an ephemeral container causes a pod to exceed its resource allocation, the pod may be evicted. Ephemeral containers may not be added by directly updating the pod spec. They must be added via the pod's ephemeralcontainers subresource, and they will appear in the pod spec once added. This is an alpha feature enabled by the EphemeralContainers feature flag. - - IoK8sApiCoreV1EphemeralContainer(; - args=nothing, - command=nothing, - env=nothing, - envFrom=nothing, - image=nothing, - imagePullPolicy=nothing, - lifecycle=nothing, - livenessProbe=nothing, - name=nothing, - ports=nothing, - readinessProbe=nothing, - resources=nothing, - securityContext=nothing, - startupProbe=nothing, - stdin=nothing, - stdinOnce=nothing, - targetContainerName=nothing, - terminationMessagePath=nothing, - terminationMessagePolicy=nothing, - tty=nothing, - volumeDevices=nothing, - volumeMounts=nothing, - workingDir=nothing, - ) - - - args::Vector{String} : Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell - - command::Vector{String} : Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell - - env::Vector{IoK8sApiCoreV1EnvVar} : List of environment variables to set in the container. Cannot be updated. - - envFrom::Vector{IoK8sApiCoreV1EnvFromSource} : List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. - - image::String : Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images - - imagePullPolicy::String : Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images - - lifecycle::IoK8sApiCoreV1Lifecycle - - livenessProbe::IoK8sApiCoreV1Probe - - name::String : Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers. - - ports::Vector{IoK8sApiCoreV1ContainerPort} : Ports are not allowed for ephemeral containers. - - readinessProbe::IoK8sApiCoreV1Probe - - resources::IoK8sApiCoreV1ResourceRequirements - - securityContext::IoK8sApiCoreV1SecurityContext - - startupProbe::IoK8sApiCoreV1Probe - - stdin::Bool : Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. - - stdinOnce::Bool : Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false - - targetContainerName::String : If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature. - - terminationMessagePath::String : Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. - - terminationMessagePolicy::String : Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. - - tty::Bool : Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. - - volumeDevices::Vector{IoK8sApiCoreV1VolumeDevice} : volumeDevices is the list of block devices to be used by the container. This is a beta feature. - - volumeMounts::Vector{IoK8sApiCoreV1VolumeMount} : Pod volumes to mount into the container's filesystem. Cannot be updated. - - workingDir::String : Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EphemeralContainer <: OpenAPI.APIModel - args::Union{Nothing, Vector{String}} = nothing - command::Union{Nothing, Vector{String}} = nothing - env::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvVar} } - envFrom::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvFromSource} } - image::Union{Nothing, String} = nothing - imagePullPolicy::Union{Nothing, String} = nothing - lifecycle = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Lifecycle } - livenessProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - name::Union{Nothing, String} = nothing - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerPort} } - readinessProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - resources = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceRequirements } - securityContext = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecurityContext } - startupProbe = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Probe } - stdin::Union{Nothing, Bool} = nothing - stdinOnce::Union{Nothing, Bool} = nothing - targetContainerName::Union{Nothing, String} = nothing - terminationMessagePath::Union{Nothing, String} = nothing - terminationMessagePolicy::Union{Nothing, String} = nothing - tty::Union{Nothing, Bool} = nothing - volumeDevices::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeDevice} } - volumeMounts::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeMount} } - workingDir::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1EphemeralContainer(args, command, env, envFrom, image, imagePullPolicy, lifecycle, livenessProbe, name, ports, readinessProbe, resources, securityContext, startupProbe, stdin, stdinOnce, targetContainerName, terminationMessagePath, terminationMessagePolicy, tty, volumeDevices, volumeMounts, workingDir, ) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("args"), args) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("command"), command) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("env"), env) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("envFrom"), envFrom) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("image"), image) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("imagePullPolicy"), imagePullPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("lifecycle"), lifecycle) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("livenessProbe"), livenessProbe) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("ports"), ports) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("readinessProbe"), readinessProbe) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("securityContext"), securityContext) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("startupProbe"), startupProbe) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("stdin"), stdin) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("stdinOnce"), stdinOnce) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("targetContainerName"), targetContainerName) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("terminationMessagePath"), terminationMessagePath) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("terminationMessagePolicy"), terminationMessagePolicy) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("tty"), tty) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("volumeDevices"), volumeDevices) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("volumeMounts"), volumeMounts) - OpenAPI.validate_property(IoK8sApiCoreV1EphemeralContainer, Symbol("workingDir"), workingDir) - return new(args, command, env, envFrom, image, imagePullPolicy, lifecycle, livenessProbe, name, ports, readinessProbe, resources, securityContext, startupProbe, stdin, stdinOnce, targetContainerName, terminationMessagePath, terminationMessagePolicy, tty, volumeDevices, volumeMounts, workingDir, ) - end -end # type IoK8sApiCoreV1EphemeralContainer - -const _property_types_IoK8sApiCoreV1EphemeralContainer = Dict{Symbol,String}(Symbol("args")=>"Vector{String}", Symbol("command")=>"Vector{String}", Symbol("env")=>"Vector{IoK8sApiCoreV1EnvVar}", Symbol("envFrom")=>"Vector{IoK8sApiCoreV1EnvFromSource}", Symbol("image")=>"String", Symbol("imagePullPolicy")=>"String", Symbol("lifecycle")=>"IoK8sApiCoreV1Lifecycle", Symbol("livenessProbe")=>"IoK8sApiCoreV1Probe", Symbol("name")=>"String", Symbol("ports")=>"Vector{IoK8sApiCoreV1ContainerPort}", Symbol("readinessProbe")=>"IoK8sApiCoreV1Probe", Symbol("resources")=>"IoK8sApiCoreV1ResourceRequirements", Symbol("securityContext")=>"IoK8sApiCoreV1SecurityContext", Symbol("startupProbe")=>"IoK8sApiCoreV1Probe", Symbol("stdin")=>"Bool", Symbol("stdinOnce")=>"Bool", Symbol("targetContainerName")=>"String", Symbol("terminationMessagePath")=>"String", Symbol("terminationMessagePolicy")=>"String", Symbol("tty")=>"Bool", Symbol("volumeDevices")=>"Vector{IoK8sApiCoreV1VolumeDevice}", Symbol("volumeMounts")=>"Vector{IoK8sApiCoreV1VolumeMount}", Symbol("workingDir")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EphemeralContainer }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EphemeralContainer[name]))} - -function check_required(o::IoK8sApiCoreV1EphemeralContainer) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EphemeralContainer }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Event.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Event.jl deleted file mode 100644 index 3bdede75..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Event.jl +++ /dev/null @@ -1,109 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Event -Event is a report of an event somewhere in the cluster. - - IoK8sApiCoreV1Event(; - action=nothing, - apiVersion=nothing, - count=nothing, - eventTime=nothing, - firstTimestamp=nothing, - involvedObject=nothing, - kind=nothing, - lastTimestamp=nothing, - message=nothing, - metadata=nothing, - reason=nothing, - related=nothing, - reportingComponent=nothing, - reportingInstance=nothing, - series=nothing, - source=nothing, - type=nothing, - ) - - - action::String : What action was taken/failed regarding to the Regarding object. - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - count::Int64 : The number of times this event has occurred. - - eventTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - firstTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - involvedObject::IoK8sApiCoreV1ObjectReference - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - lastTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human-readable description of the status of this operation. - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - reason::String : This should be a short, machine understandable string that gives the reason for the transition into the object's current status. - - related::IoK8sApiCoreV1ObjectReference - - reportingComponent::String : Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. - - reportingInstance::String : ID of the controller instance, e.g. `kubelet-xyzf`. - - series::IoK8sApiCoreV1EventSeries - - source::IoK8sApiCoreV1EventSource - - type::String : Type of this event (Normal, Warning), new types could be added in the future -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Event <: OpenAPI.APIModel - action::Union{Nothing, String} = nothing - apiVersion::Union{Nothing, String} = nothing - count::Union{Nothing, Int64} = nothing - eventTime::Union{Nothing, ZonedDateTime} = nothing - firstTimestamp::Union{Nothing, ZonedDateTime} = nothing - involvedObject = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - kind::Union{Nothing, String} = nothing - lastTimestamp::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - reason::Union{Nothing, String} = nothing - related = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - reportingComponent::Union{Nothing, String} = nothing - reportingInstance::Union{Nothing, String} = nothing - series = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1EventSeries } - source = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1EventSource } - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Event(action, apiVersion, count, eventTime, firstTimestamp, involvedObject, kind, lastTimestamp, message, metadata, reason, related, reportingComponent, reportingInstance, series, source, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("action"), action) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("count"), count) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("eventTime"), eventTime) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("firstTimestamp"), firstTimestamp) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("involvedObject"), involvedObject) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("lastTimestamp"), lastTimestamp) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("related"), related) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("reportingComponent"), reportingComponent) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("reportingInstance"), reportingInstance) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("series"), series) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("source"), source) - OpenAPI.validate_property(IoK8sApiCoreV1Event, Symbol("type"), type) - return new(action, apiVersion, count, eventTime, firstTimestamp, involvedObject, kind, lastTimestamp, message, metadata, reason, related, reportingComponent, reportingInstance, series, source, type, ) - end -end # type IoK8sApiCoreV1Event - -const _property_types_IoK8sApiCoreV1Event = Dict{Symbol,String}(Symbol("action")=>"String", Symbol("apiVersion")=>"String", Symbol("count")=>"Int64", Symbol("eventTime")=>"ZonedDateTime", Symbol("firstTimestamp")=>"ZonedDateTime", Symbol("involvedObject")=>"IoK8sApiCoreV1ObjectReference", Symbol("kind")=>"String", Symbol("lastTimestamp")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("reason")=>"String", Symbol("related")=>"IoK8sApiCoreV1ObjectReference", Symbol("reportingComponent")=>"String", Symbol("reportingInstance")=>"String", Symbol("series")=>"IoK8sApiCoreV1EventSeries", Symbol("source")=>"IoK8sApiCoreV1EventSource", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Event }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Event[name]))} - -function check_required(o::IoK8sApiCoreV1Event) - o.involvedObject === nothing && (return false) - o.metadata === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Event }, name::Symbol, val) - if name === Symbol("count") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Event", :format, val, "int32") - end - if name === Symbol("eventTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Event", :format, val, "date-time") - end - if name === Symbol("firstTimestamp") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Event", :format, val, "date-time") - end - if name === Symbol("lastTimestamp") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Event", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventList.jl deleted file mode 100644 index 02a3fdf5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EventList -EventList is a list of events. - - IoK8sApiCoreV1EventList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Event} : List of events - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EventList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Event} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1EventList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1EventList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1EventList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1EventList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1EventList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1EventList - -const _property_types_IoK8sApiCoreV1EventList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Event}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EventList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EventList[name]))} - -function check_required(o::IoK8sApiCoreV1EventList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EventList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSeries.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSeries.jl deleted file mode 100644 index ec4f6c7d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSeries.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EventSeries -EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. - - IoK8sApiCoreV1EventSeries(; - count=nothing, - lastObservedTime=nothing, - state=nothing, - ) - - - count::Int64 : Number of occurrences in this series up to the last heartbeat time - - lastObservedTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - state::String : State of this Series: Ongoing or Finished Deprecated. Planned removal for 1.18 -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EventSeries <: OpenAPI.APIModel - count::Union{Nothing, Int64} = nothing - lastObservedTime::Union{Nothing, ZonedDateTime} = nothing - state::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1EventSeries(count, lastObservedTime, state, ) - OpenAPI.validate_property(IoK8sApiCoreV1EventSeries, Symbol("count"), count) - OpenAPI.validate_property(IoK8sApiCoreV1EventSeries, Symbol("lastObservedTime"), lastObservedTime) - OpenAPI.validate_property(IoK8sApiCoreV1EventSeries, Symbol("state"), state) - return new(count, lastObservedTime, state, ) - end -end # type IoK8sApiCoreV1EventSeries - -const _property_types_IoK8sApiCoreV1EventSeries = Dict{Symbol,String}(Symbol("count")=>"Int64", Symbol("lastObservedTime")=>"ZonedDateTime", Symbol("state")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EventSeries }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EventSeries[name]))} - -function check_required(o::IoK8sApiCoreV1EventSeries) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EventSeries }, name::Symbol, val) - if name === Symbol("count") - OpenAPI.validate_param(name, "IoK8sApiCoreV1EventSeries", :format, val, "int32") - end - if name === Symbol("lastObservedTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1EventSeries", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSource.jl deleted file mode 100644 index cfb1bafb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1EventSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.EventSource -EventSource contains information for an event. - - IoK8sApiCoreV1EventSource(; - component=nothing, - host=nothing, - ) - - - component::String : Component from which the event is generated. - - host::String : Node name on which the event is generated. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1EventSource <: OpenAPI.APIModel - component::Union{Nothing, String} = nothing - host::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1EventSource(component, host, ) - OpenAPI.validate_property(IoK8sApiCoreV1EventSource, Symbol("component"), component) - OpenAPI.validate_property(IoK8sApiCoreV1EventSource, Symbol("host"), host) - return new(component, host, ) - end -end # type IoK8sApiCoreV1EventSource - -const _property_types_IoK8sApiCoreV1EventSource = Dict{Symbol,String}(Symbol("component")=>"String", Symbol("host")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1EventSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1EventSource[name]))} - -function check_required(o::IoK8sApiCoreV1EventSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1EventSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ExecAction.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ExecAction.jl deleted file mode 100644 index dea4eace..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ExecAction.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ExecAction -ExecAction describes a \"run in container\" action. - - IoK8sApiCoreV1ExecAction(; - command=nothing, - ) - - - command::Vector{String} : Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ExecAction <: OpenAPI.APIModel - command::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1ExecAction(command, ) - OpenAPI.validate_property(IoK8sApiCoreV1ExecAction, Symbol("command"), command) - return new(command, ) - end -end # type IoK8sApiCoreV1ExecAction - -const _property_types_IoK8sApiCoreV1ExecAction = Dict{Symbol,String}(Symbol("command")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ExecAction }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ExecAction[name]))} - -function check_required(o::IoK8sApiCoreV1ExecAction) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ExecAction }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FCVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1FCVolumeSource.jl deleted file mode 100644 index 607c304f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FCVolumeSource.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.FCVolumeSource -Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1FCVolumeSource(; - fsType=nothing, - lun=nothing, - readOnly=nothing, - targetWWNs=nothing, - wwids=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - lun::Int64 : Optional: FC target lun number - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - targetWWNs::Vector{String} : Optional: FC target worldwide names (WWNs) - - wwids::Vector{String} : Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1FCVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - lun::Union{Nothing, Int64} = nothing - readOnly::Union{Nothing, Bool} = nothing - targetWWNs::Union{Nothing, Vector{String}} = nothing - wwids::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1FCVolumeSource(fsType, lun, readOnly, targetWWNs, wwids, ) - OpenAPI.validate_property(IoK8sApiCoreV1FCVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1FCVolumeSource, Symbol("lun"), lun) - OpenAPI.validate_property(IoK8sApiCoreV1FCVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1FCVolumeSource, Symbol("targetWWNs"), targetWWNs) - OpenAPI.validate_property(IoK8sApiCoreV1FCVolumeSource, Symbol("wwids"), wwids) - return new(fsType, lun, readOnly, targetWWNs, wwids, ) - end -end # type IoK8sApiCoreV1FCVolumeSource - -const _property_types_IoK8sApiCoreV1FCVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("lun")=>"Int64", Symbol("readOnly")=>"Bool", Symbol("targetWWNs")=>"Vector{String}", Symbol("wwids")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1FCVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1FCVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1FCVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1FCVolumeSource }, name::Symbol, val) - if name === Symbol("lun") - OpenAPI.validate_param(name, "IoK8sApiCoreV1FCVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexPersistentVolumeSource.jl deleted file mode 100644 index 8acf02fb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexPersistentVolumeSource.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.FlexPersistentVolumeSource -FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin. - - IoK8sApiCoreV1FlexPersistentVolumeSource(; - driver=nothing, - fsType=nothing, - options=nothing, - readOnly=nothing, - secretRef=nothing, - ) - - - driver::String : Driver is the name of the driver to use for this volume. - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script. - - options::Dict{String, String} : Optional: Extra command options if any. - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1SecretReference -""" -Base.@kwdef mutable struct IoK8sApiCoreV1FlexPersistentVolumeSource <: OpenAPI.APIModel - driver::Union{Nothing, String} = nothing - fsType::Union{Nothing, String} = nothing - options::Union{Nothing, Dict{String, String}} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - - function IoK8sApiCoreV1FlexPersistentVolumeSource(driver, fsType, options, readOnly, secretRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1FlexPersistentVolumeSource, Symbol("driver"), driver) - OpenAPI.validate_property(IoK8sApiCoreV1FlexPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1FlexPersistentVolumeSource, Symbol("options"), options) - OpenAPI.validate_property(IoK8sApiCoreV1FlexPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1FlexPersistentVolumeSource, Symbol("secretRef"), secretRef) - return new(driver, fsType, options, readOnly, secretRef, ) - end -end # type IoK8sApiCoreV1FlexPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1FlexPersistentVolumeSource = Dict{Symbol,String}(Symbol("driver")=>"String", Symbol("fsType")=>"String", Symbol("options")=>"Dict{String, String}", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1FlexPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1FlexPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1FlexPersistentVolumeSource) - o.driver === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1FlexPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexVolumeSource.jl deleted file mode 100644 index 3a012fc2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlexVolumeSource.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.FlexVolumeSource -FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. - - IoK8sApiCoreV1FlexVolumeSource(; - driver=nothing, - fsType=nothing, - options=nothing, - readOnly=nothing, - secretRef=nothing, - ) - - - driver::String : Driver is the name of the driver to use for this volume. - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script. - - options::Dict{String, String} : Optional: Extra command options if any. - - readOnly::Bool : Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1LocalObjectReference -""" -Base.@kwdef mutable struct IoK8sApiCoreV1FlexVolumeSource <: OpenAPI.APIModel - driver::Union{Nothing, String} = nothing - fsType::Union{Nothing, String} = nothing - options::Union{Nothing, Dict{String, String}} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - - function IoK8sApiCoreV1FlexVolumeSource(driver, fsType, options, readOnly, secretRef, ) - OpenAPI.validate_property(IoK8sApiCoreV1FlexVolumeSource, Symbol("driver"), driver) - OpenAPI.validate_property(IoK8sApiCoreV1FlexVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1FlexVolumeSource, Symbol("options"), options) - OpenAPI.validate_property(IoK8sApiCoreV1FlexVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1FlexVolumeSource, Symbol("secretRef"), secretRef) - return new(driver, fsType, options, readOnly, secretRef, ) - end -end # type IoK8sApiCoreV1FlexVolumeSource - -const _property_types_IoK8sApiCoreV1FlexVolumeSource = Dict{Symbol,String}(Symbol("driver")=>"String", Symbol("fsType")=>"String", Symbol("options")=>"Dict{String, String}", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1FlexVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1FlexVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1FlexVolumeSource) - o.driver === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1FlexVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlockerVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlockerVolumeSource.jl deleted file mode 100644 index 604bf6a1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1FlockerVolumeSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.FlockerVolumeSource -Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1FlockerVolumeSource(; - datasetName=nothing, - datasetUUID=nothing, - ) - - - datasetName::String : Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated - - datasetUUID::String : UUID of the dataset. This is unique identifier of a Flocker dataset -""" -Base.@kwdef mutable struct IoK8sApiCoreV1FlockerVolumeSource <: OpenAPI.APIModel - datasetName::Union{Nothing, String} = nothing - datasetUUID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1FlockerVolumeSource(datasetName, datasetUUID, ) - OpenAPI.validate_property(IoK8sApiCoreV1FlockerVolumeSource, Symbol("datasetName"), datasetName) - OpenAPI.validate_property(IoK8sApiCoreV1FlockerVolumeSource, Symbol("datasetUUID"), datasetUUID) - return new(datasetName, datasetUUID, ) - end -end # type IoK8sApiCoreV1FlockerVolumeSource - -const _property_types_IoK8sApiCoreV1FlockerVolumeSource = Dict{Symbol,String}(Symbol("datasetName")=>"String", Symbol("datasetUUID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1FlockerVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1FlockerVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1FlockerVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1FlockerVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GCEPersistentDiskVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1GCEPersistentDiskVolumeSource.jl deleted file mode 100644 index 9f404d20..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GCEPersistentDiskVolumeSource.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.GCEPersistentDiskVolumeSource -Represents a Persistent Disk resource in Google Compute Engine. A GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling. - - IoK8sApiCoreV1GCEPersistentDiskVolumeSource(; - fsType=nothing, - partition=nothing, - pdName=nothing, - readOnly=nothing, - ) - - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk - - partition::Int64 : The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk - - pdName::String : Unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk - - readOnly::Bool : ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk -""" -Base.@kwdef mutable struct IoK8sApiCoreV1GCEPersistentDiskVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - partition::Union{Nothing, Int64} = nothing - pdName::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1GCEPersistentDiskVolumeSource(fsType, partition, pdName, readOnly, ) - OpenAPI.validate_property(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, Symbol("partition"), partition) - OpenAPI.validate_property(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, Symbol("pdName"), pdName) - OpenAPI.validate_property(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, Symbol("readOnly"), readOnly) - return new(fsType, partition, pdName, readOnly, ) - end -end # type IoK8sApiCoreV1GCEPersistentDiskVolumeSource - -const _property_types_IoK8sApiCoreV1GCEPersistentDiskVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("partition")=>"Int64", Symbol("pdName")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1GCEPersistentDiskVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1GCEPersistentDiskVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) - o.pdName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1GCEPersistentDiskVolumeSource }, name::Symbol, val) - if name === Symbol("partition") - OpenAPI.validate_param(name, "IoK8sApiCoreV1GCEPersistentDiskVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GitRepoVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1GitRepoVolumeSource.jl deleted file mode 100644 index 86f3aff1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GitRepoVolumeSource.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.GitRepoVolumeSource -Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. - - IoK8sApiCoreV1GitRepoVolumeSource(; - directory=nothing, - repository=nothing, - revision=nothing, - ) - - - directory::String : Target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. - - repository::String : Repository URL - - revision::String : Commit hash for the specified revision. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1GitRepoVolumeSource <: OpenAPI.APIModel - directory::Union{Nothing, String} = nothing - repository::Union{Nothing, String} = nothing - revision::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1GitRepoVolumeSource(directory, repository, revision, ) - OpenAPI.validate_property(IoK8sApiCoreV1GitRepoVolumeSource, Symbol("directory"), directory) - OpenAPI.validate_property(IoK8sApiCoreV1GitRepoVolumeSource, Symbol("repository"), repository) - OpenAPI.validate_property(IoK8sApiCoreV1GitRepoVolumeSource, Symbol("revision"), revision) - return new(directory, repository, revision, ) - end -end # type IoK8sApiCoreV1GitRepoVolumeSource - -const _property_types_IoK8sApiCoreV1GitRepoVolumeSource = Dict{Symbol,String}(Symbol("directory")=>"String", Symbol("repository")=>"String", Symbol("revision")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1GitRepoVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1GitRepoVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1GitRepoVolumeSource) - o.repository === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1GitRepoVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsPersistentVolumeSource.jl deleted file mode 100644 index 84ca7e50..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsPersistentVolumeSource.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.GlusterfsPersistentVolumeSource -Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1GlusterfsPersistentVolumeSource(; - endpoints=nothing, - endpointsNamespace=nothing, - path=nothing, - readOnly=nothing, - ) - - - endpoints::String : EndpointsName is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod - - endpointsNamespace::String : EndpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod - - path::String : Path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod - - readOnly::Bool : ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod -""" -Base.@kwdef mutable struct IoK8sApiCoreV1GlusterfsPersistentVolumeSource <: OpenAPI.APIModel - endpoints::Union{Nothing, String} = nothing - endpointsNamespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1GlusterfsPersistentVolumeSource(endpoints, endpointsNamespace, path, readOnly, ) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, Symbol("endpoints"), endpoints) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, Symbol("endpointsNamespace"), endpointsNamespace) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, Symbol("readOnly"), readOnly) - return new(endpoints, endpointsNamespace, path, readOnly, ) - end -end # type IoK8sApiCoreV1GlusterfsPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1GlusterfsPersistentVolumeSource = Dict{Symbol,String}(Symbol("endpoints")=>"String", Symbol("endpointsNamespace")=>"String", Symbol("path")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1GlusterfsPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1GlusterfsPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1GlusterfsPersistentVolumeSource) - o.endpoints === nothing && (return false) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1GlusterfsPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsVolumeSource.jl deleted file mode 100644 index 2511b218..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1GlusterfsVolumeSource.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.GlusterfsVolumeSource -Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1GlusterfsVolumeSource(; - endpoints=nothing, - path=nothing, - readOnly=nothing, - ) - - - endpoints::String : EndpointsName is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod - - path::String : Path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod - - readOnly::Bool : ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod -""" -Base.@kwdef mutable struct IoK8sApiCoreV1GlusterfsVolumeSource <: OpenAPI.APIModel - endpoints::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1GlusterfsVolumeSource(endpoints, path, readOnly, ) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsVolumeSource, Symbol("endpoints"), endpoints) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1GlusterfsVolumeSource, Symbol("readOnly"), readOnly) - return new(endpoints, path, readOnly, ) - end -end # type IoK8sApiCoreV1GlusterfsVolumeSource - -const _property_types_IoK8sApiCoreV1GlusterfsVolumeSource = Dict{Symbol,String}(Symbol("endpoints")=>"String", Symbol("path")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1GlusterfsVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1GlusterfsVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1GlusterfsVolumeSource) - o.endpoints === nothing && (return false) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1GlusterfsVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPGetAction.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPGetAction.jl deleted file mode 100644 index ff15fa78..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPGetAction.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.HTTPGetAction -HTTPGetAction describes an action based on HTTP Get requests. - - IoK8sApiCoreV1HTTPGetAction(; - host=nothing, - httpHeaders=nothing, - path=nothing, - port=nothing, - scheme=nothing, - ) - - - host::String : Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead. - - httpHeaders::Vector{IoK8sApiCoreV1HTTPHeader} : Custom headers to set in the request. HTTP allows repeated headers. - - path::String : Path to access on the HTTP server. - - port::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - scheme::String : Scheme to use for connecting to the host. Defaults to HTTP. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1HTTPGetAction <: OpenAPI.APIModel - host::Union{Nothing, String} = nothing - httpHeaders::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1HTTPHeader} } - path::Union{Nothing, String} = nothing - port::Union{Nothing, Any} = nothing - scheme::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1HTTPGetAction(host, httpHeaders, path, port, scheme, ) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPGetAction, Symbol("host"), host) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPGetAction, Symbol("httpHeaders"), httpHeaders) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPGetAction, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPGetAction, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPGetAction, Symbol("scheme"), scheme) - return new(host, httpHeaders, path, port, scheme, ) - end -end # type IoK8sApiCoreV1HTTPGetAction - -const _property_types_IoK8sApiCoreV1HTTPGetAction = Dict{Symbol,String}(Symbol("host")=>"String", Symbol("httpHeaders")=>"Vector{IoK8sApiCoreV1HTTPHeader}", Symbol("path")=>"String", Symbol("port")=>"Any", Symbol("scheme")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1HTTPGetAction }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1HTTPGetAction[name]))} - -function check_required(o::IoK8sApiCoreV1HTTPGetAction) - o.port === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1HTTPGetAction }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiCoreV1HTTPGetAction", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPHeader.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPHeader.jl deleted file mode 100644 index 41303040..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HTTPHeader.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.HTTPHeader -HTTPHeader describes a custom header to be used in HTTP probes - - IoK8sApiCoreV1HTTPHeader(; - name=nothing, - value=nothing, - ) - - - name::String : The header field name - - value::String : The header field value -""" -Base.@kwdef mutable struct IoK8sApiCoreV1HTTPHeader <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1HTTPHeader(name, value, ) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPHeader, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1HTTPHeader, Symbol("value"), value) - return new(name, value, ) - end -end # type IoK8sApiCoreV1HTTPHeader - -const _property_types_IoK8sApiCoreV1HTTPHeader = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1HTTPHeader }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1HTTPHeader[name]))} - -function check_required(o::IoK8sApiCoreV1HTTPHeader) - o.name === nothing && (return false) - o.value === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1HTTPHeader }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Handler.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Handler.jl deleted file mode 100644 index a64ad80f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Handler.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Handler -Handler defines a specific action that should be taken - - IoK8sApiCoreV1Handler(; - exec=nothing, - httpGet=nothing, - tcpSocket=nothing, - ) - - - exec::IoK8sApiCoreV1ExecAction - - httpGet::IoK8sApiCoreV1HTTPGetAction - - tcpSocket::IoK8sApiCoreV1TCPSocketAction -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Handler <: OpenAPI.APIModel - exec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ExecAction } - httpGet = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1HTTPGetAction } - tcpSocket = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1TCPSocketAction } - - function IoK8sApiCoreV1Handler(exec, httpGet, tcpSocket, ) - OpenAPI.validate_property(IoK8sApiCoreV1Handler, Symbol("exec"), exec) - OpenAPI.validate_property(IoK8sApiCoreV1Handler, Symbol("httpGet"), httpGet) - OpenAPI.validate_property(IoK8sApiCoreV1Handler, Symbol("tcpSocket"), tcpSocket) - return new(exec, httpGet, tcpSocket, ) - end -end # type IoK8sApiCoreV1Handler - -const _property_types_IoK8sApiCoreV1Handler = Dict{Symbol,String}(Symbol("exec")=>"IoK8sApiCoreV1ExecAction", Symbol("httpGet")=>"IoK8sApiCoreV1HTTPGetAction", Symbol("tcpSocket")=>"IoK8sApiCoreV1TCPSocketAction", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Handler }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Handler[name]))} - -function check_required(o::IoK8sApiCoreV1Handler) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Handler }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostAlias.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostAlias.jl deleted file mode 100644 index c477f7e3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostAlias.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.HostAlias -HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file. - - IoK8sApiCoreV1HostAlias(; - hostnames=nothing, - ip=nothing, - ) - - - hostnames::Vector{String} : Hostnames for the above IP address. - - ip::String : IP address of the host file entry. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1HostAlias <: OpenAPI.APIModel - hostnames::Union{Nothing, Vector{String}} = nothing - ip::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1HostAlias(hostnames, ip, ) - OpenAPI.validate_property(IoK8sApiCoreV1HostAlias, Symbol("hostnames"), hostnames) - OpenAPI.validate_property(IoK8sApiCoreV1HostAlias, Symbol("ip"), ip) - return new(hostnames, ip, ) - end -end # type IoK8sApiCoreV1HostAlias - -const _property_types_IoK8sApiCoreV1HostAlias = Dict{Symbol,String}(Symbol("hostnames")=>"Vector{String}", Symbol("ip")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1HostAlias }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1HostAlias[name]))} - -function check_required(o::IoK8sApiCoreV1HostAlias) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1HostAlias }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostPathVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostPathVolumeSource.jl deleted file mode 100644 index a2ea22bb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1HostPathVolumeSource.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.HostPathVolumeSource -Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1HostPathVolumeSource(; - path=nothing, - type=nothing, - ) - - - path::String : Path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath - - type::String : Type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath -""" -Base.@kwdef mutable struct IoK8sApiCoreV1HostPathVolumeSource <: OpenAPI.APIModel - path::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1HostPathVolumeSource(path, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1HostPathVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1HostPathVolumeSource, Symbol("type"), type) - return new(path, type, ) - end -end # type IoK8sApiCoreV1HostPathVolumeSource - -const _property_types_IoK8sApiCoreV1HostPathVolumeSource = Dict{Symbol,String}(Symbol("path")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1HostPathVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1HostPathVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1HostPathVolumeSource) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1HostPathVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIPersistentVolumeSource.jl deleted file mode 100644 index 4a31969a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIPersistentVolumeSource.jl +++ /dev/null @@ -1,77 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ISCSIPersistentVolumeSource -ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1ISCSIPersistentVolumeSource(; - chapAuthDiscovery=nothing, - chapAuthSession=nothing, - fsType=nothing, - initiatorName=nothing, - iqn=nothing, - iscsiInterface=nothing, - lun=nothing, - portals=nothing, - readOnly=nothing, - secretRef=nothing, - targetPortal=nothing, - ) - - - chapAuthDiscovery::Bool : whether support iSCSI Discovery CHAP authentication - - chapAuthSession::Bool : whether support iSCSI Session CHAP authentication - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi - - initiatorName::String : Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface <target portal>:<volume name> will be created for the connection. - - iqn::String : Target iSCSI Qualified Name. - - iscsiInterface::String : iSCSI Interface Name that uses an iSCSI transport. Defaults to 'default' (tcp). - - lun::Int64 : iSCSI Target Lun number. - - portals::Vector{String} : iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). - - readOnly::Bool : ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. - - secretRef::IoK8sApiCoreV1SecretReference - - targetPortal::String : iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ISCSIPersistentVolumeSource <: OpenAPI.APIModel - chapAuthDiscovery::Union{Nothing, Bool} = nothing - chapAuthSession::Union{Nothing, Bool} = nothing - fsType::Union{Nothing, String} = nothing - initiatorName::Union{Nothing, String} = nothing - iqn::Union{Nothing, String} = nothing - iscsiInterface::Union{Nothing, String} = nothing - lun::Union{Nothing, Int64} = nothing - portals::Union{Nothing, Vector{String}} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - targetPortal::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ISCSIPersistentVolumeSource(chapAuthDiscovery, chapAuthSession, fsType, initiatorName, iqn, iscsiInterface, lun, portals, readOnly, secretRef, targetPortal, ) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("chapAuthDiscovery"), chapAuthDiscovery) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("chapAuthSession"), chapAuthSession) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("initiatorName"), initiatorName) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("iqn"), iqn) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("iscsiInterface"), iscsiInterface) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("lun"), lun) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("portals"), portals) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIPersistentVolumeSource, Symbol("targetPortal"), targetPortal) - return new(chapAuthDiscovery, chapAuthSession, fsType, initiatorName, iqn, iscsiInterface, lun, portals, readOnly, secretRef, targetPortal, ) - end -end # type IoK8sApiCoreV1ISCSIPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1ISCSIPersistentVolumeSource = Dict{Symbol,String}(Symbol("chapAuthDiscovery")=>"Bool", Symbol("chapAuthSession")=>"Bool", Symbol("fsType")=>"String", Symbol("initiatorName")=>"String", Symbol("iqn")=>"String", Symbol("iscsiInterface")=>"String", Symbol("lun")=>"Int64", Symbol("portals")=>"Vector{String}", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("targetPortal")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ISCSIPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ISCSIPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ISCSIPersistentVolumeSource) - o.iqn === nothing && (return false) - o.lun === nothing && (return false) - o.targetPortal === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ISCSIPersistentVolumeSource }, name::Symbol, val) - if name === Symbol("lun") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ISCSIPersistentVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIVolumeSource.jl deleted file mode 100644 index ccd4d999..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ISCSIVolumeSource.jl +++ /dev/null @@ -1,77 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ISCSIVolumeSource -Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1ISCSIVolumeSource(; - chapAuthDiscovery=nothing, - chapAuthSession=nothing, - fsType=nothing, - initiatorName=nothing, - iqn=nothing, - iscsiInterface=nothing, - lun=nothing, - portals=nothing, - readOnly=nothing, - secretRef=nothing, - targetPortal=nothing, - ) - - - chapAuthDiscovery::Bool : whether support iSCSI Discovery CHAP authentication - - chapAuthSession::Bool : whether support iSCSI Session CHAP authentication - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi - - initiatorName::String : Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface <target portal>:<volume name> will be created for the connection. - - iqn::String : Target iSCSI Qualified Name. - - iscsiInterface::String : iSCSI Interface Name that uses an iSCSI transport. Defaults to 'default' (tcp). - - lun::Int64 : iSCSI Target Lun number. - - portals::Vector{String} : iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). - - readOnly::Bool : ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. - - secretRef::IoK8sApiCoreV1LocalObjectReference - - targetPortal::String : iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ISCSIVolumeSource <: OpenAPI.APIModel - chapAuthDiscovery::Union{Nothing, Bool} = nothing - chapAuthSession::Union{Nothing, Bool} = nothing - fsType::Union{Nothing, String} = nothing - initiatorName::Union{Nothing, String} = nothing - iqn::Union{Nothing, String} = nothing - iscsiInterface::Union{Nothing, String} = nothing - lun::Union{Nothing, Int64} = nothing - portals::Union{Nothing, Vector{String}} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - targetPortal::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ISCSIVolumeSource(chapAuthDiscovery, chapAuthSession, fsType, initiatorName, iqn, iscsiInterface, lun, portals, readOnly, secretRef, targetPortal, ) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("chapAuthDiscovery"), chapAuthDiscovery) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("chapAuthSession"), chapAuthSession) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("initiatorName"), initiatorName) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("iqn"), iqn) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("iscsiInterface"), iscsiInterface) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("lun"), lun) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("portals"), portals) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1ISCSIVolumeSource, Symbol("targetPortal"), targetPortal) - return new(chapAuthDiscovery, chapAuthSession, fsType, initiatorName, iqn, iscsiInterface, lun, portals, readOnly, secretRef, targetPortal, ) - end -end # type IoK8sApiCoreV1ISCSIVolumeSource - -const _property_types_IoK8sApiCoreV1ISCSIVolumeSource = Dict{Symbol,String}(Symbol("chapAuthDiscovery")=>"Bool", Symbol("chapAuthSession")=>"Bool", Symbol("fsType")=>"String", Symbol("initiatorName")=>"String", Symbol("iqn")=>"String", Symbol("iscsiInterface")=>"String", Symbol("lun")=>"Int64", Symbol("portals")=>"Vector{String}", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("targetPortal")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ISCSIVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ISCSIVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ISCSIVolumeSource) - o.iqn === nothing && (return false) - o.lun === nothing && (return false) - o.targetPortal === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ISCSIVolumeSource }, name::Symbol, val) - if name === Symbol("lun") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ISCSIVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1KeyToPath.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1KeyToPath.jl deleted file mode 100644 index 9411bf04..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1KeyToPath.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.KeyToPath -Maps a string key to a path within a volume. - - IoK8sApiCoreV1KeyToPath(; - key=nothing, - mode=nothing, - path=nothing, - ) - - - key::String : The key to project. - - mode::Int64 : Optional: mode bits to use on this file, must be a value between 0 and 0777. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - path::String : The relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1KeyToPath <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - mode::Union{Nothing, Int64} = nothing - path::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1KeyToPath(key, mode, path, ) - OpenAPI.validate_property(IoK8sApiCoreV1KeyToPath, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1KeyToPath, Symbol("mode"), mode) - OpenAPI.validate_property(IoK8sApiCoreV1KeyToPath, Symbol("path"), path) - return new(key, mode, path, ) - end -end # type IoK8sApiCoreV1KeyToPath - -const _property_types_IoK8sApiCoreV1KeyToPath = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("mode")=>"Int64", Symbol("path")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1KeyToPath }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1KeyToPath[name]))} - -function check_required(o::IoK8sApiCoreV1KeyToPath) - o.key === nothing && (return false) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1KeyToPath }, name::Symbol, val) - if name === Symbol("mode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1KeyToPath", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Lifecycle.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Lifecycle.jl deleted file mode 100644 index 61a5d928..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Lifecycle.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Lifecycle -Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted. - - IoK8sApiCoreV1Lifecycle(; - postStart=nothing, - preStop=nothing, - ) - - - postStart::IoK8sApiCoreV1Handler - - preStop::IoK8sApiCoreV1Handler -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Lifecycle <: OpenAPI.APIModel - postStart = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Handler } - preStop = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Handler } - - function IoK8sApiCoreV1Lifecycle(postStart, preStop, ) - OpenAPI.validate_property(IoK8sApiCoreV1Lifecycle, Symbol("postStart"), postStart) - OpenAPI.validate_property(IoK8sApiCoreV1Lifecycle, Symbol("preStop"), preStop) - return new(postStart, preStop, ) - end -end # type IoK8sApiCoreV1Lifecycle - -const _property_types_IoK8sApiCoreV1Lifecycle = Dict{Symbol,String}(Symbol("postStart")=>"IoK8sApiCoreV1Handler", Symbol("preStop")=>"IoK8sApiCoreV1Handler", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Lifecycle }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Lifecycle[name]))} - -function check_required(o::IoK8sApiCoreV1Lifecycle) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Lifecycle }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRange.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRange.jl deleted file mode 100644 index aae93361..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRange.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LimitRange -LimitRange sets resource usage limits for each kind of resource in a Namespace. - - IoK8sApiCoreV1LimitRange(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1LimitRangeSpec -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LimitRange <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LimitRangeSpec } - - function IoK8sApiCoreV1LimitRange(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRange, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRange, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRange, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRange, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiCoreV1LimitRange - -const _property_types_IoK8sApiCoreV1LimitRange = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1LimitRangeSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LimitRange }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LimitRange[name]))} - -function check_required(o::IoK8sApiCoreV1LimitRange) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LimitRange }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeItem.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeItem.jl deleted file mode 100644 index 25441bdd..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeItem.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LimitRangeItem -LimitRangeItem defines a min/max usage limit for any resource that matches on kind. - - IoK8sApiCoreV1LimitRangeItem(; - default=nothing, - defaultRequest=nothing, - max=nothing, - maxLimitRequestRatio=nothing, - min=nothing, - type=nothing, - ) - - - default::Dict{String, String} : Default resource requirement limit value by resource name if resource limit is omitted. - - defaultRequest::Dict{String, String} : DefaultRequest is the default resource requirement request value by resource name if resource request is omitted. - - max::Dict{String, String} : Max usage constraints on this kind by resource name. - - maxLimitRequestRatio::Dict{String, String} : MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource. - - min::Dict{String, String} : Min usage constraints on this kind by resource name. - - type::String : Type of resource that this limit applies to. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LimitRangeItem <: OpenAPI.APIModel - default::Union{Nothing, Dict{String, String}} = nothing - defaultRequest::Union{Nothing, Dict{String, String}} = nothing - max::Union{Nothing, Dict{String, String}} = nothing - maxLimitRequestRatio::Union{Nothing, Dict{String, String}} = nothing - min::Union{Nothing, Dict{String, String}} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1LimitRangeItem(default, defaultRequest, max, maxLimitRequestRatio, min, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("default"), default) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("defaultRequest"), defaultRequest) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("max"), max) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("maxLimitRequestRatio"), maxLimitRequestRatio) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("min"), min) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeItem, Symbol("type"), type) - return new(default, defaultRequest, max, maxLimitRequestRatio, min, type, ) - end -end # type IoK8sApiCoreV1LimitRangeItem - -const _property_types_IoK8sApiCoreV1LimitRangeItem = Dict{Symbol,String}(Symbol("default")=>"Dict{String, String}", Symbol("defaultRequest")=>"Dict{String, String}", Symbol("max")=>"Dict{String, String}", Symbol("maxLimitRequestRatio")=>"Dict{String, String}", Symbol("min")=>"Dict{String, String}", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LimitRangeItem }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LimitRangeItem[name]))} - -function check_required(o::IoK8sApiCoreV1LimitRangeItem) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LimitRangeItem }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeList.jl deleted file mode 100644 index 54263d73..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LimitRangeList -LimitRangeList is a list of LimitRange items. - - IoK8sApiCoreV1LimitRangeList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1LimitRange} : Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/ - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LimitRangeList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1LimitRange} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1LimitRangeList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1LimitRangeList - -const _property_types_IoK8sApiCoreV1LimitRangeList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1LimitRange}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LimitRangeList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LimitRangeList[name]))} - -function check_required(o::IoK8sApiCoreV1LimitRangeList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LimitRangeList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeSpec.jl deleted file mode 100644 index c66c0db3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LimitRangeSpec.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LimitRangeSpec -LimitRangeSpec defines a min/max usage limit for resources that match on kind. - - IoK8sApiCoreV1LimitRangeSpec(; - limits=nothing, - ) - - - limits::Vector{IoK8sApiCoreV1LimitRangeItem} : Limits is the list of LimitRangeItem objects that are enforced. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LimitRangeSpec <: OpenAPI.APIModel - limits::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1LimitRangeItem} } - - function IoK8sApiCoreV1LimitRangeSpec(limits, ) - OpenAPI.validate_property(IoK8sApiCoreV1LimitRangeSpec, Symbol("limits"), limits) - return new(limits, ) - end -end # type IoK8sApiCoreV1LimitRangeSpec - -const _property_types_IoK8sApiCoreV1LimitRangeSpec = Dict{Symbol,String}(Symbol("limits")=>"Vector{IoK8sApiCoreV1LimitRangeItem}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LimitRangeSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LimitRangeSpec[name]))} - -function check_required(o::IoK8sApiCoreV1LimitRangeSpec) - o.limits === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LimitRangeSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerIngress.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerIngress.jl deleted file mode 100644 index 6b99c484..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerIngress.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LoadBalancerIngress -LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point. - - IoK8sApiCoreV1LoadBalancerIngress(; - hostname=nothing, - ip=nothing, - ) - - - hostname::String : Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers) - - ip::String : IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers) -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LoadBalancerIngress <: OpenAPI.APIModel - hostname::Union{Nothing, String} = nothing - ip::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1LoadBalancerIngress(hostname, ip, ) - OpenAPI.validate_property(IoK8sApiCoreV1LoadBalancerIngress, Symbol("hostname"), hostname) - OpenAPI.validate_property(IoK8sApiCoreV1LoadBalancerIngress, Symbol("ip"), ip) - return new(hostname, ip, ) - end -end # type IoK8sApiCoreV1LoadBalancerIngress - -const _property_types_IoK8sApiCoreV1LoadBalancerIngress = Dict{Symbol,String}(Symbol("hostname")=>"String", Symbol("ip")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LoadBalancerIngress }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LoadBalancerIngress[name]))} - -function check_required(o::IoK8sApiCoreV1LoadBalancerIngress) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LoadBalancerIngress }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerStatus.jl deleted file mode 100644 index ba846cc0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LoadBalancerStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LoadBalancerStatus -LoadBalancerStatus represents the status of a load-balancer. - - IoK8sApiCoreV1LoadBalancerStatus(; - ingress=nothing, - ) - - - ingress::Vector{IoK8sApiCoreV1LoadBalancerIngress} : Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LoadBalancerStatus <: OpenAPI.APIModel - ingress::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1LoadBalancerIngress} } - - function IoK8sApiCoreV1LoadBalancerStatus(ingress, ) - OpenAPI.validate_property(IoK8sApiCoreV1LoadBalancerStatus, Symbol("ingress"), ingress) - return new(ingress, ) - end -end # type IoK8sApiCoreV1LoadBalancerStatus - -const _property_types_IoK8sApiCoreV1LoadBalancerStatus = Dict{Symbol,String}(Symbol("ingress")=>"Vector{IoK8sApiCoreV1LoadBalancerIngress}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LoadBalancerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LoadBalancerStatus[name]))} - -function check_required(o::IoK8sApiCoreV1LoadBalancerStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LoadBalancerStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalObjectReference.jl deleted file mode 100644 index 74ab6bb6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalObjectReference.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LocalObjectReference -LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. - - IoK8sApiCoreV1LocalObjectReference(; - name=nothing, - ) - - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LocalObjectReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1LocalObjectReference(name, ) - OpenAPI.validate_property(IoK8sApiCoreV1LocalObjectReference, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiCoreV1LocalObjectReference - -const _property_types_IoK8sApiCoreV1LocalObjectReference = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LocalObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LocalObjectReference[name]))} - -function check_required(o::IoK8sApiCoreV1LocalObjectReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LocalObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalVolumeSource.jl deleted file mode 100644 index 224d6b2f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1LocalVolumeSource.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.LocalVolumeSource -Local represents directly-attached storage with node affinity (Beta feature) - - IoK8sApiCoreV1LocalVolumeSource(; - fsType=nothing, - path=nothing, - ) - - - fsType::String : Filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a fileystem if unspecified. - - path::String : The full path to the volume on the node. It can be either a directory or block device (disk, partition, ...). -""" -Base.@kwdef mutable struct IoK8sApiCoreV1LocalVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1LocalVolumeSource(fsType, path, ) - OpenAPI.validate_property(IoK8sApiCoreV1LocalVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1LocalVolumeSource, Symbol("path"), path) - return new(fsType, path, ) - end -end # type IoK8sApiCoreV1LocalVolumeSource - -const _property_types_IoK8sApiCoreV1LocalVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("path")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1LocalVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1LocalVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1LocalVolumeSource) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1LocalVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NFSVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NFSVolumeSource.jl deleted file mode 100644 index 1fc37d94..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NFSVolumeSource.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NFSVolumeSource -Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1NFSVolumeSource(; - path=nothing, - readOnly=nothing, - server=nothing, - ) - - - path::String : Path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs - - readOnly::Bool : ReadOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs - - server::String : Server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NFSVolumeSource <: OpenAPI.APIModel - path::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - server::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NFSVolumeSource(path, readOnly, server, ) - OpenAPI.validate_property(IoK8sApiCoreV1NFSVolumeSource, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiCoreV1NFSVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1NFSVolumeSource, Symbol("server"), server) - return new(path, readOnly, server, ) - end -end # type IoK8sApiCoreV1NFSVolumeSource - -const _property_types_IoK8sApiCoreV1NFSVolumeSource = Dict{Symbol,String}(Symbol("path")=>"String", Symbol("readOnly")=>"Bool", Symbol("server")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NFSVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NFSVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1NFSVolumeSource) - o.path === nothing && (return false) - o.server === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NFSVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Namespace.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Namespace.jl deleted file mode 100644 index b7997008..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Namespace.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Namespace -Namespace provides a scope for Names. Use of multiple namespaces is optional. - - IoK8sApiCoreV1Namespace(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1NamespaceSpec - - status::IoK8sApiCoreV1NamespaceStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Namespace <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NamespaceSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NamespaceStatus } - - function IoK8sApiCoreV1Namespace(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1Namespace, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Namespace, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Namespace, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Namespace, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1Namespace, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1Namespace - -const _property_types_IoK8sApiCoreV1Namespace = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1NamespaceSpec", Symbol("status")=>"IoK8sApiCoreV1NamespaceStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Namespace }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Namespace[name]))} - -function check_required(o::IoK8sApiCoreV1Namespace) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Namespace }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceCondition.jl deleted file mode 100644 index 12dba09b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NamespaceCondition -NamespaceCondition contains details about state of namespace. - - IoK8sApiCoreV1NamespaceCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String - - reason::String - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of namespace controller condition. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NamespaceCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NamespaceCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiCoreV1NamespaceCondition - -const _property_types_IoK8sApiCoreV1NamespaceCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NamespaceCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NamespaceCondition[name]))} - -function check_required(o::IoK8sApiCoreV1NamespaceCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NamespaceCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1NamespaceCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceList.jl deleted file mode 100644 index b38c2348..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NamespaceList -NamespaceList is a list of Namespaces. - - IoK8sApiCoreV1NamespaceList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Namespace} : Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NamespaceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Namespace} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1NamespaceList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1NamespaceList - -const _property_types_IoK8sApiCoreV1NamespaceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Namespace}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NamespaceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NamespaceList[name]))} - -function check_required(o::IoK8sApiCoreV1NamespaceList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NamespaceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceSpec.jl deleted file mode 100644 index ca1c331a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceSpec.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NamespaceSpec -NamespaceSpec describes the attributes on a Namespace. - - IoK8sApiCoreV1NamespaceSpec(; - finalizers=nothing, - ) - - - finalizers::Vector{String} : Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NamespaceSpec <: OpenAPI.APIModel - finalizers::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1NamespaceSpec(finalizers, ) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceSpec, Symbol("finalizers"), finalizers) - return new(finalizers, ) - end -end # type IoK8sApiCoreV1NamespaceSpec - -const _property_types_IoK8sApiCoreV1NamespaceSpec = Dict{Symbol,String}(Symbol("finalizers")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NamespaceSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NamespaceSpec[name]))} - -function check_required(o::IoK8sApiCoreV1NamespaceSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NamespaceSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceStatus.jl deleted file mode 100644 index fc54be5a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NamespaceStatus.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NamespaceStatus -NamespaceStatus is information about the current status of a Namespace. - - IoK8sApiCoreV1NamespaceStatus(; - conditions=nothing, - phase=nothing, - ) - - - conditions::Vector{IoK8sApiCoreV1NamespaceCondition} : Represents the latest available observations of a namespace's current state. - - phase::String : Phase is the current lifecycle phase of the namespace. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NamespaceStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NamespaceCondition} } - phase::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NamespaceStatus(conditions, phase, ) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1NamespaceStatus, Symbol("phase"), phase) - return new(conditions, phase, ) - end -end # type IoK8sApiCoreV1NamespaceStatus - -const _property_types_IoK8sApiCoreV1NamespaceStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiCoreV1NamespaceCondition}", Symbol("phase")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NamespaceStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NamespaceStatus[name]))} - -function check_required(o::IoK8sApiCoreV1NamespaceStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NamespaceStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Node.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Node.jl deleted file mode 100644 index 2d3c3b09..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Node.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Node -Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd). - - IoK8sApiCoreV1Node(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1NodeSpec - - status::IoK8sApiCoreV1NodeStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Node <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeStatus } - - function IoK8sApiCoreV1Node(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1Node, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Node, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Node, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Node, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1Node, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1Node - -const _property_types_IoK8sApiCoreV1Node = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1NodeSpec", Symbol("status")=>"IoK8sApiCoreV1NodeStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Node }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Node[name]))} - -function check_required(o::IoK8sApiCoreV1Node) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Node }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAddress.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAddress.jl deleted file mode 100644 index 1551cf34..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAddress.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeAddress -NodeAddress contains information for the node's address. - - IoK8sApiCoreV1NodeAddress(; - address=nothing, - type=nothing, - ) - - - address::String : The node address. - - type::String : Node address type, one of Hostname, ExternalIP or InternalIP. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeAddress <: OpenAPI.APIModel - address::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NodeAddress(address, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeAddress, Symbol("address"), address) - OpenAPI.validate_property(IoK8sApiCoreV1NodeAddress, Symbol("type"), type) - return new(address, type, ) - end -end # type IoK8sApiCoreV1NodeAddress - -const _property_types_IoK8sApiCoreV1NodeAddress = Dict{Symbol,String}(Symbol("address")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeAddress }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeAddress[name]))} - -function check_required(o::IoK8sApiCoreV1NodeAddress) - o.address === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeAddress }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAffinity.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAffinity.jl deleted file mode 100644 index e7f5ee3e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeAffinity.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeAffinity -Node affinity is a group of node affinity scheduling rules. - - IoK8sApiCoreV1NodeAffinity(; - preferredDuringSchedulingIgnoredDuringExecution=nothing, - requiredDuringSchedulingIgnoredDuringExecution=nothing, - ) - - - preferredDuringSchedulingIgnoredDuringExecution::Vector{IoK8sApiCoreV1PreferredSchedulingTerm} : The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. - - requiredDuringSchedulingIgnoredDuringExecution::IoK8sApiCoreV1NodeSelector -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeAffinity <: OpenAPI.APIModel - preferredDuringSchedulingIgnoredDuringExecution::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PreferredSchedulingTerm} } - requiredDuringSchedulingIgnoredDuringExecution = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeSelector } - - function IoK8sApiCoreV1NodeAffinity(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeAffinity, Symbol("preferredDuringSchedulingIgnoredDuringExecution"), preferredDuringSchedulingIgnoredDuringExecution) - OpenAPI.validate_property(IoK8sApiCoreV1NodeAffinity, Symbol("requiredDuringSchedulingIgnoredDuringExecution"), requiredDuringSchedulingIgnoredDuringExecution) - return new(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - end -end # type IoK8sApiCoreV1NodeAffinity - -const _property_types_IoK8sApiCoreV1NodeAffinity = Dict{Symbol,String}(Symbol("preferredDuringSchedulingIgnoredDuringExecution")=>"Vector{IoK8sApiCoreV1PreferredSchedulingTerm}", Symbol("requiredDuringSchedulingIgnoredDuringExecution")=>"IoK8sApiCoreV1NodeSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeAffinity }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeAffinity[name]))} - -function check_required(o::IoK8sApiCoreV1NodeAffinity) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeAffinity }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeCondition.jl deleted file mode 100644 index 6f9ed58f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeCondition -NodeCondition contains condition information for a node. - - IoK8sApiCoreV1NodeCondition(; - lastHeartbeatTime=nothing, - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastHeartbeatTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human readable message indicating details about last transition. - - reason::String : (brief) reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of node condition. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeCondition <: OpenAPI.APIModel - lastHeartbeatTime::Union{Nothing, ZonedDateTime} = nothing - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NodeCondition(lastHeartbeatTime, lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("lastHeartbeatTime"), lastHeartbeatTime) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1NodeCondition, Symbol("type"), type) - return new(lastHeartbeatTime, lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiCoreV1NodeCondition - -const _property_types_IoK8sApiCoreV1NodeCondition = Dict{Symbol,String}(Symbol("lastHeartbeatTime")=>"ZonedDateTime", Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeCondition[name]))} - -function check_required(o::IoK8sApiCoreV1NodeCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeCondition }, name::Symbol, val) - if name === Symbol("lastHeartbeatTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1NodeCondition", :format, val, "date-time") - end - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1NodeCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigSource.jl deleted file mode 100644 index 4ac48766..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigSource.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeConfigSource -NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. - - IoK8sApiCoreV1NodeConfigSource(; - configMap=nothing, - ) - - - configMap::IoK8sApiCoreV1ConfigMapNodeConfigSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeConfigSource <: OpenAPI.APIModel - configMap = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ConfigMapNodeConfigSource } - - function IoK8sApiCoreV1NodeConfigSource(configMap, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeConfigSource, Symbol("configMap"), configMap) - return new(configMap, ) - end -end # type IoK8sApiCoreV1NodeConfigSource - -const _property_types_IoK8sApiCoreV1NodeConfigSource = Dict{Symbol,String}(Symbol("configMap")=>"IoK8sApiCoreV1ConfigMapNodeConfigSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeConfigSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeConfigSource[name]))} - -function check_required(o::IoK8sApiCoreV1NodeConfigSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeConfigSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigStatus.jl deleted file mode 100644 index ee0e3dd8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeConfigStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeConfigStatus -NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource. - - IoK8sApiCoreV1NodeConfigStatus(; - active=nothing, - assigned=nothing, - error=nothing, - lastKnownGood=nothing, - ) - - - active::IoK8sApiCoreV1NodeConfigSource - - assigned::IoK8sApiCoreV1NodeConfigSource - - error::String : Error describes any problems reconciling the Spec.ConfigSource to the Active config. Errors may occur, for example, attempting to checkpoint Spec.ConfigSource to the local Assigned record, attempting to checkpoint the payload associated with Spec.ConfigSource, attempting to load or validate the Assigned config, etc. Errors may occur at different points while syncing config. Earlier errors (e.g. download or checkpointing errors) will not result in a rollback to LastKnownGood, and may resolve across Kubelet retries. Later errors (e.g. loading or validating a checkpointed config) will result in a rollback to LastKnownGood. In the latter case, it is usually possible to resolve the error by fixing the config assigned in Spec.ConfigSource. You can find additional information for debugging by searching the error message in the Kubelet log. Error is a human-readable description of the error state; machines can check whether or not Error is empty, but should not rely on the stability of the Error text across Kubelet versions. - - lastKnownGood::IoK8sApiCoreV1NodeConfigSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeConfigStatus <: OpenAPI.APIModel - active = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeConfigSource } - assigned = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeConfigSource } - error::Union{Nothing, String} = nothing - lastKnownGood = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeConfigSource } - - function IoK8sApiCoreV1NodeConfigStatus(active, assigned, error, lastKnownGood, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeConfigStatus, Symbol("active"), active) - OpenAPI.validate_property(IoK8sApiCoreV1NodeConfigStatus, Symbol("assigned"), assigned) - OpenAPI.validate_property(IoK8sApiCoreV1NodeConfigStatus, Symbol("error"), error) - OpenAPI.validate_property(IoK8sApiCoreV1NodeConfigStatus, Symbol("lastKnownGood"), lastKnownGood) - return new(active, assigned, error, lastKnownGood, ) - end -end # type IoK8sApiCoreV1NodeConfigStatus - -const _property_types_IoK8sApiCoreV1NodeConfigStatus = Dict{Symbol,String}(Symbol("active")=>"IoK8sApiCoreV1NodeConfigSource", Symbol("assigned")=>"IoK8sApiCoreV1NodeConfigSource", Symbol("error")=>"String", Symbol("lastKnownGood")=>"IoK8sApiCoreV1NodeConfigSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeConfigStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeConfigStatus[name]))} - -function check_required(o::IoK8sApiCoreV1NodeConfigStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeConfigStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeDaemonEndpoints.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeDaemonEndpoints.jl deleted file mode 100644 index 8601e22a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeDaemonEndpoints.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeDaemonEndpoints -NodeDaemonEndpoints lists ports opened by daemons running on the Node. - - IoK8sApiCoreV1NodeDaemonEndpoints(; - kubeletEndpoint=nothing, - ) - - - kubeletEndpoint::IoK8sApiCoreV1DaemonEndpoint -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeDaemonEndpoints <: OpenAPI.APIModel - kubeletEndpoint = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1DaemonEndpoint } - - function IoK8sApiCoreV1NodeDaemonEndpoints(kubeletEndpoint, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeDaemonEndpoints, Symbol("kubeletEndpoint"), kubeletEndpoint) - return new(kubeletEndpoint, ) - end -end # type IoK8sApiCoreV1NodeDaemonEndpoints - -const _property_types_IoK8sApiCoreV1NodeDaemonEndpoints = Dict{Symbol,String}(Symbol("kubeletEndpoint")=>"IoK8sApiCoreV1DaemonEndpoint", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeDaemonEndpoints }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeDaemonEndpoints[name]))} - -function check_required(o::IoK8sApiCoreV1NodeDaemonEndpoints) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeDaemonEndpoints }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeList.jl deleted file mode 100644 index 19f0705a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeList -NodeList is the whole list of all Nodes which have been registered with master. - - IoK8sApiCoreV1NodeList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Node} : List of nodes - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Node} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1NodeList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NodeList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1NodeList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1NodeList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1NodeList - -const _property_types_IoK8sApiCoreV1NodeList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Node}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeList[name]))} - -function check_required(o::IoK8sApiCoreV1NodeList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelector.jl deleted file mode 100644 index 93fba7ab..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelector.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeSelector -A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms. - - IoK8sApiCoreV1NodeSelector(; - nodeSelectorTerms=nothing, - ) - - - nodeSelectorTerms::Vector{IoK8sApiCoreV1NodeSelectorTerm} : Required. A list of node selector terms. The terms are ORed. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeSelector <: OpenAPI.APIModel - nodeSelectorTerms::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NodeSelectorTerm} } - - function IoK8sApiCoreV1NodeSelector(nodeSelectorTerms, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelector, Symbol("nodeSelectorTerms"), nodeSelectorTerms) - return new(nodeSelectorTerms, ) - end -end # type IoK8sApiCoreV1NodeSelector - -const _property_types_IoK8sApiCoreV1NodeSelector = Dict{Symbol,String}(Symbol("nodeSelectorTerms")=>"Vector{IoK8sApiCoreV1NodeSelectorTerm}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeSelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeSelector[name]))} - -function check_required(o::IoK8sApiCoreV1NodeSelector) - o.nodeSelectorTerms === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeSelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorRequirement.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorRequirement.jl deleted file mode 100644 index 42ae1f08..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorRequirement.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeSelectorRequirement -A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. - - IoK8sApiCoreV1NodeSelectorRequirement(; - key=nothing, - operator=nothing, - values=nothing, - ) - - - key::String : The label key that the selector applies to. - - operator::String : Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. - - values::Vector{String} : An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeSelectorRequirement <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - operator::Union{Nothing, String} = nothing - values::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1NodeSelectorRequirement(key, operator, values, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelectorRequirement, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelectorRequirement, Symbol("operator"), operator) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelectorRequirement, Symbol("values"), values) - return new(key, operator, values, ) - end -end # type IoK8sApiCoreV1NodeSelectorRequirement - -const _property_types_IoK8sApiCoreV1NodeSelectorRequirement = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("operator")=>"String", Symbol("values")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeSelectorRequirement }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeSelectorRequirement[name]))} - -function check_required(o::IoK8sApiCoreV1NodeSelectorRequirement) - o.key === nothing && (return false) - o.operator === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeSelectorRequirement }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorTerm.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorTerm.jl deleted file mode 100644 index f7690a97..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSelectorTerm.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeSelectorTerm -A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. - - IoK8sApiCoreV1NodeSelectorTerm(; - matchExpressions=nothing, - matchFields=nothing, - ) - - - matchExpressions::Vector{IoK8sApiCoreV1NodeSelectorRequirement} : A list of node selector requirements by node's labels. - - matchFields::Vector{IoK8sApiCoreV1NodeSelectorRequirement} : A list of node selector requirements by node's fields. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeSelectorTerm <: OpenAPI.APIModel - matchExpressions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NodeSelectorRequirement} } - matchFields::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NodeSelectorRequirement} } - - function IoK8sApiCoreV1NodeSelectorTerm(matchExpressions, matchFields, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelectorTerm, Symbol("matchExpressions"), matchExpressions) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSelectorTerm, Symbol("matchFields"), matchFields) - return new(matchExpressions, matchFields, ) - end -end # type IoK8sApiCoreV1NodeSelectorTerm - -const _property_types_IoK8sApiCoreV1NodeSelectorTerm = Dict{Symbol,String}(Symbol("matchExpressions")=>"Vector{IoK8sApiCoreV1NodeSelectorRequirement}", Symbol("matchFields")=>"Vector{IoK8sApiCoreV1NodeSelectorRequirement}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeSelectorTerm }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeSelectorTerm[name]))} - -function check_required(o::IoK8sApiCoreV1NodeSelectorTerm) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeSelectorTerm }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSpec.jl deleted file mode 100644 index 26e75e06..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSpec.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeSpec -NodeSpec describes the attributes that a node is created with. - - IoK8sApiCoreV1NodeSpec(; - configSource=nothing, - externalID=nothing, - podCIDR=nothing, - podCIDRs=nothing, - providerID=nothing, - taints=nothing, - unschedulable=nothing, - ) - - - configSource::IoK8sApiCoreV1NodeConfigSource - - externalID::String : Deprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966 - - podCIDR::String : PodCIDR represents the pod IP range assigned to the node. - - podCIDRs::Vector{String} : podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6. - - providerID::String : ID of the node assigned by the cloud provider in the format: <ProviderName>://<ProviderSpecificNodeID> - - taints::Vector{IoK8sApiCoreV1Taint} : If specified, the node's taints. - - unschedulable::Bool : Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeSpec <: OpenAPI.APIModel - configSource = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeConfigSource } - externalID::Union{Nothing, String} = nothing - podCIDR::Union{Nothing, String} = nothing - podCIDRs::Union{Nothing, Vector{String}} = nothing - providerID::Union{Nothing, String} = nothing - taints::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Taint} } - unschedulable::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1NodeSpec(configSource, externalID, podCIDR, podCIDRs, providerID, taints, unschedulable, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("configSource"), configSource) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("externalID"), externalID) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("podCIDR"), podCIDR) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("podCIDRs"), podCIDRs) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("providerID"), providerID) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("taints"), taints) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSpec, Symbol("unschedulable"), unschedulable) - return new(configSource, externalID, podCIDR, podCIDRs, providerID, taints, unschedulable, ) - end -end # type IoK8sApiCoreV1NodeSpec - -const _property_types_IoK8sApiCoreV1NodeSpec = Dict{Symbol,String}(Symbol("configSource")=>"IoK8sApiCoreV1NodeConfigSource", Symbol("externalID")=>"String", Symbol("podCIDR")=>"String", Symbol("podCIDRs")=>"Vector{String}", Symbol("providerID")=>"String", Symbol("taints")=>"Vector{IoK8sApiCoreV1Taint}", Symbol("unschedulable")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeSpec[name]))} - -function check_required(o::IoK8sApiCoreV1NodeSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeStatus.jl deleted file mode 100644 index e3908ed1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeStatus.jl +++ /dev/null @@ -1,71 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeStatus -NodeStatus is information about the current status of a node. - - IoK8sApiCoreV1NodeStatus(; - addresses=nothing, - allocatable=nothing, - capacity=nothing, - conditions=nothing, - config=nothing, - daemonEndpoints=nothing, - images=nothing, - nodeInfo=nothing, - phase=nothing, - volumesAttached=nothing, - volumesInUse=nothing, - ) - - - addresses::Vector{IoK8sApiCoreV1NodeAddress} : List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See http://pr.k8s.io/79391 for an example. - - allocatable::Dict{String, String} : Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity. - - capacity::Dict{String, String} : Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity - - conditions::Vector{IoK8sApiCoreV1NodeCondition} : Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/concepts/nodes/node/#condition - - config::IoK8sApiCoreV1NodeConfigStatus - - daemonEndpoints::IoK8sApiCoreV1NodeDaemonEndpoints - - images::Vector{IoK8sApiCoreV1ContainerImage} : List of container images on this node - - nodeInfo::IoK8sApiCoreV1NodeSystemInfo - - phase::String : NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated. - - volumesAttached::Vector{IoK8sApiCoreV1AttachedVolume} : List of volumes that are attached to the node. - - volumesInUse::Vector{String} : List of attachable volumes in use (mounted) by the node. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeStatus <: OpenAPI.APIModel - addresses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NodeAddress} } - allocatable::Union{Nothing, Dict{String, String}} = nothing - capacity::Union{Nothing, Dict{String, String}} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1NodeCondition} } - config = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeConfigStatus } - daemonEndpoints = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeDaemonEndpoints } - images::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerImage} } - nodeInfo = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeSystemInfo } - phase::Union{Nothing, String} = nothing - volumesAttached::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1AttachedVolume} } - volumesInUse::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1NodeStatus(addresses, allocatable, capacity, conditions, config, daemonEndpoints, images, nodeInfo, phase, volumesAttached, volumesInUse, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("addresses"), addresses) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("allocatable"), allocatable) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("capacity"), capacity) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("config"), config) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("daemonEndpoints"), daemonEndpoints) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("images"), images) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("nodeInfo"), nodeInfo) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("phase"), phase) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("volumesAttached"), volumesAttached) - OpenAPI.validate_property(IoK8sApiCoreV1NodeStatus, Symbol("volumesInUse"), volumesInUse) - return new(addresses, allocatable, capacity, conditions, config, daemonEndpoints, images, nodeInfo, phase, volumesAttached, volumesInUse, ) - end -end # type IoK8sApiCoreV1NodeStatus - -const _property_types_IoK8sApiCoreV1NodeStatus = Dict{Symbol,String}(Symbol("addresses")=>"Vector{IoK8sApiCoreV1NodeAddress}", Symbol("allocatable")=>"Dict{String, String}", Symbol("capacity")=>"Dict{String, String}", Symbol("conditions")=>"Vector{IoK8sApiCoreV1NodeCondition}", Symbol("config")=>"IoK8sApiCoreV1NodeConfigStatus", Symbol("daemonEndpoints")=>"IoK8sApiCoreV1NodeDaemonEndpoints", Symbol("images")=>"Vector{IoK8sApiCoreV1ContainerImage}", Symbol("nodeInfo")=>"IoK8sApiCoreV1NodeSystemInfo", Symbol("phase")=>"String", Symbol("volumesAttached")=>"Vector{IoK8sApiCoreV1AttachedVolume}", Symbol("volumesInUse")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeStatus[name]))} - -function check_required(o::IoK8sApiCoreV1NodeStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSystemInfo.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSystemInfo.jl deleted file mode 100644 index d6203267..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1NodeSystemInfo.jl +++ /dev/null @@ -1,77 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.NodeSystemInfo -NodeSystemInfo is a set of ids/uuids to uniquely identify the node. - - IoK8sApiCoreV1NodeSystemInfo(; - architecture=nothing, - bootID=nothing, - containerRuntimeVersion=nothing, - kernelVersion=nothing, - kubeProxyVersion=nothing, - kubeletVersion=nothing, - machineID=nothing, - operatingSystem=nothing, - osImage=nothing, - systemUUID=nothing, - ) - - - architecture::String : The Architecture reported by the node - - bootID::String : Boot ID reported by the node. - - containerRuntimeVersion::String : ContainerRuntime Version reported by the node through runtime remote API (e.g. docker://1.5.0). - - kernelVersion::String : Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64). - - kubeProxyVersion::String : KubeProxy Version reported by the node. - - kubeletVersion::String : Kubelet Version reported by the node. - - machineID::String : MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html - - operatingSystem::String : The Operating System reported by the node - - osImage::String : OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)). - - systemUUID::String : SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-US/Red_Hat_Subscription_Management/1/html/RHSM/getting-system-uuid.html -""" -Base.@kwdef mutable struct IoK8sApiCoreV1NodeSystemInfo <: OpenAPI.APIModel - architecture::Union{Nothing, String} = nothing - bootID::Union{Nothing, String} = nothing - containerRuntimeVersion::Union{Nothing, String} = nothing - kernelVersion::Union{Nothing, String} = nothing - kubeProxyVersion::Union{Nothing, String} = nothing - kubeletVersion::Union{Nothing, String} = nothing - machineID::Union{Nothing, String} = nothing - operatingSystem::Union{Nothing, String} = nothing - osImage::Union{Nothing, String} = nothing - systemUUID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1NodeSystemInfo(architecture, bootID, containerRuntimeVersion, kernelVersion, kubeProxyVersion, kubeletVersion, machineID, operatingSystem, osImage, systemUUID, ) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("architecture"), architecture) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("bootID"), bootID) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("containerRuntimeVersion"), containerRuntimeVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("kernelVersion"), kernelVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("kubeProxyVersion"), kubeProxyVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("kubeletVersion"), kubeletVersion) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("machineID"), machineID) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("operatingSystem"), operatingSystem) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("osImage"), osImage) - OpenAPI.validate_property(IoK8sApiCoreV1NodeSystemInfo, Symbol("systemUUID"), systemUUID) - return new(architecture, bootID, containerRuntimeVersion, kernelVersion, kubeProxyVersion, kubeletVersion, machineID, operatingSystem, osImage, systemUUID, ) - end -end # type IoK8sApiCoreV1NodeSystemInfo - -const _property_types_IoK8sApiCoreV1NodeSystemInfo = Dict{Symbol,String}(Symbol("architecture")=>"String", Symbol("bootID")=>"String", Symbol("containerRuntimeVersion")=>"String", Symbol("kernelVersion")=>"String", Symbol("kubeProxyVersion")=>"String", Symbol("kubeletVersion")=>"String", Symbol("machineID")=>"String", Symbol("operatingSystem")=>"String", Symbol("osImage")=>"String", Symbol("systemUUID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1NodeSystemInfo }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1NodeSystemInfo[name]))} - -function check_required(o::IoK8sApiCoreV1NodeSystemInfo) - o.architecture === nothing && (return false) - o.bootID === nothing && (return false) - o.containerRuntimeVersion === nothing && (return false) - o.kernelVersion === nothing && (return false) - o.kubeProxyVersion === nothing && (return false) - o.kubeletVersion === nothing && (return false) - o.machineID === nothing && (return false) - o.operatingSystem === nothing && (return false) - o.osImage === nothing && (return false) - o.systemUUID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1NodeSystemInfo }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectFieldSelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectFieldSelector.jl deleted file mode 100644 index 3cc7c449..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectFieldSelector.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ObjectFieldSelector -ObjectFieldSelector selects an APIVersioned field of an object. - - IoK8sApiCoreV1ObjectFieldSelector(; - apiVersion=nothing, - fieldPath=nothing, - ) - - - apiVersion::String : Version of the schema the FieldPath is written in terms of, defaults to \"v1\". - - fieldPath::String : Path of the field to select in the specified API version. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ObjectFieldSelector <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - fieldPath::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ObjectFieldSelector(apiVersion, fieldPath, ) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectFieldSelector, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectFieldSelector, Symbol("fieldPath"), fieldPath) - return new(apiVersion, fieldPath, ) - end -end # type IoK8sApiCoreV1ObjectFieldSelector - -const _property_types_IoK8sApiCoreV1ObjectFieldSelector = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("fieldPath")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ObjectFieldSelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ObjectFieldSelector[name]))} - -function check_required(o::IoK8sApiCoreV1ObjectFieldSelector) - o.fieldPath === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ObjectFieldSelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectReference.jl deleted file mode 100644 index 262cdca1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ObjectReference.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ObjectReference -ObjectReference contains enough information to let you inspect or modify the referred object. - - IoK8sApiCoreV1ObjectReference(; - apiVersion=nothing, - fieldPath=nothing, - kind=nothing, - name=nothing, - namespace=nothing, - resourceVersion=nothing, - uid=nothing, - ) - - - apiVersion::String : API version of the referent. - - fieldPath::String : If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object. - - kind::String : Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - namespace::String : Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ - - resourceVersion::String : Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency - - uid::String : UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ObjectReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - fieldPath::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - resourceVersion::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ObjectReference(apiVersion, fieldPath, kind, name, namespace, resourceVersion, uid, ) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("fieldPath"), fieldPath) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("resourceVersion"), resourceVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ObjectReference, Symbol("uid"), uid) - return new(apiVersion, fieldPath, kind, name, namespace, resourceVersion, uid, ) - end -end # type IoK8sApiCoreV1ObjectReference - -const _property_types_IoK8sApiCoreV1ObjectReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("fieldPath")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("resourceVersion")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ObjectReference[name]))} - -function check_required(o::IoK8sApiCoreV1ObjectReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolume.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolume.jl deleted file mode 100644 index 3f9f357b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolume.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolume -PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes - - IoK8sApiCoreV1PersistentVolume(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1PersistentVolumeSpec - - status::IoK8sApiCoreV1PersistentVolumeStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolume <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeStatus } - - function IoK8sApiCoreV1PersistentVolume(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolume, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolume, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolume, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolume, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolume, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1PersistentVolume - -const _property_types_IoK8sApiCoreV1PersistentVolume = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1PersistentVolumeSpec", Symbol("status")=>"IoK8sApiCoreV1PersistentVolumeStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolume }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolume[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolume) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolume }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaim.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaim.jl deleted file mode 100644 index 9752e324..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaim.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaim -PersistentVolumeClaim is a user's request for and claim to a persistent volume - - IoK8sApiCoreV1PersistentVolumeClaim(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1PersistentVolumeClaimSpec - - status::IoK8sApiCoreV1PersistentVolumeClaimStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaim <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeClaimSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeClaimStatus } - - function IoK8sApiCoreV1PersistentVolumeClaim(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaim, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaim, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaim, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaim, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaim, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaim - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaim = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1PersistentVolumeClaimSpec", Symbol("status")=>"IoK8sApiCoreV1PersistentVolumeClaimStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaim }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaim[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaim) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaim }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimCondition.jl deleted file mode 100644 index 7adc2d4e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaimCondition -PersistentVolumeClaimCondition contails details about state of pvc - - IoK8sApiCoreV1PersistentVolumeClaimCondition(; - lastProbeTime=nothing, - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastProbeTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human-readable message indicating details about last transition. - - reason::String : Unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized. - - status::String - - type::String -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaimCondition <: OpenAPI.APIModel - lastProbeTime::Union{Nothing, ZonedDateTime} = nothing - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PersistentVolumeClaimCondition(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("lastProbeTime"), lastProbeTime) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimCondition, Symbol("type"), type) - return new(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaimCondition - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaimCondition = Dict{Symbol,String}(Symbol("lastProbeTime")=>"ZonedDateTime", Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaimCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaimCondition[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaimCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaimCondition }, name::Symbol, val) - if name === Symbol("lastProbeTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PersistentVolumeClaimCondition", :format, val, "date-time") - end - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PersistentVolumeClaimCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimList.jl deleted file mode 100644 index 87957841..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaimList -PersistentVolumeClaimList is a list of PersistentVolumeClaim items. - - IoK8sApiCoreV1PersistentVolumeClaimList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1PersistentVolumeClaim} : A list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaimList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolumeClaim} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1PersistentVolumeClaimList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaimList - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaimList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1PersistentVolumeClaim}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaimList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaimList[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaimList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaimList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimSpec.jl deleted file mode 100644 index 2f17ef01..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimSpec.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaimSpec -PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes - - IoK8sApiCoreV1PersistentVolumeClaimSpec(; - accessModes=nothing, - dataSource=nothing, - resources=nothing, - selector=nothing, - storageClassName=nothing, - volumeMode=nothing, - volumeName=nothing, - ) - - - accessModes::Vector{String} : AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 - - dataSource::IoK8sApiCoreV1TypedLocalObjectReference - - resources::IoK8sApiCoreV1ResourceRequirements - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - storageClassName::String : Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 - - volumeMode::String : volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. This is a beta feature. - - volumeName::String : VolumeName is the binding reference to the PersistentVolume backing this claim. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaimSpec <: OpenAPI.APIModel - accessModes::Union{Nothing, Vector{String}} = nothing - dataSource = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1TypedLocalObjectReference } - resources = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceRequirements } - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - storageClassName::Union{Nothing, String} = nothing - volumeMode::Union{Nothing, String} = nothing - volumeName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PersistentVolumeClaimSpec(accessModes, dataSource, resources, selector, storageClassName, volumeMode, volumeName, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("accessModes"), accessModes) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("dataSource"), dataSource) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("storageClassName"), storageClassName) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("volumeMode"), volumeMode) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimSpec, Symbol("volumeName"), volumeName) - return new(accessModes, dataSource, resources, selector, storageClassName, volumeMode, volumeName, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaimSpec - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaimSpec = Dict{Symbol,String}(Symbol("accessModes")=>"Vector{String}", Symbol("dataSource")=>"IoK8sApiCoreV1TypedLocalObjectReference", Symbol("resources")=>"IoK8sApiCoreV1ResourceRequirements", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("storageClassName")=>"String", Symbol("volumeMode")=>"String", Symbol("volumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaimSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaimSpec[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaimSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaimSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimStatus.jl deleted file mode 100644 index 54540a11..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaimStatus -PersistentVolumeClaimStatus is the current status of a persistent volume claim. - - IoK8sApiCoreV1PersistentVolumeClaimStatus(; - accessModes=nothing, - capacity=nothing, - conditions=nothing, - phase=nothing, - ) - - - accessModes::Vector{String} : AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 - - capacity::Dict{String, String} : Represents the actual resources of the underlying volume. - - conditions::Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition} : Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'. - - phase::String : Phase represents the current phase of PersistentVolumeClaim. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaimStatus <: OpenAPI.APIModel - accessModes::Union{Nothing, Vector{String}} = nothing - capacity::Union{Nothing, Dict{String, String}} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition} } - phase::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PersistentVolumeClaimStatus(accessModes, capacity, conditions, phase, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimStatus, Symbol("accessModes"), accessModes) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimStatus, Symbol("capacity"), capacity) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimStatus, Symbol("phase"), phase) - return new(accessModes, capacity, conditions, phase, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaimStatus - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaimStatus = Dict{Symbol,String}(Symbol("accessModes")=>"Vector{String}", Symbol("capacity")=>"Dict{String, String}", Symbol("conditions")=>"Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition}", Symbol("phase")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaimStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaimStatus[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaimStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaimStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource.jl deleted file mode 100644 index 99377a22..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource -PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). - - IoK8sApiCoreV1PersistentVolumeClaimVolumeSource(; - claimName=nothing, - readOnly=nothing, - ) - - - claimName::String : ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims - - readOnly::Bool : Will force the ReadOnly setting in VolumeMounts. Default false. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeClaimVolumeSource <: OpenAPI.APIModel - claimName::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1PersistentVolumeClaimVolumeSource(claimName, readOnly, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimVolumeSource, Symbol("claimName"), claimName) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeClaimVolumeSource, Symbol("readOnly"), readOnly) - return new(claimName, readOnly, ) - end -end # type IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - -const _property_types_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource = Dict{Symbol,String}(Symbol("claimName")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeClaimVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeClaimVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) - o.claimName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeClaimVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeList.jl deleted file mode 100644 index 2c5a92f4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeList -PersistentVolumeList is a list of PersistentVolume items. - - IoK8sApiCoreV1PersistentVolumeList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1PersistentVolume} : List of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PersistentVolume} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1PersistentVolumeList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1PersistentVolumeList - -const _property_types_IoK8sApiCoreV1PersistentVolumeList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1PersistentVolume}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeList[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeSpec.jl deleted file mode 100644 index 9eb356b6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeSpec.jl +++ /dev/null @@ -1,147 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeSpec -PersistentVolumeSpec is the specification of a persistent volume. - - IoK8sApiCoreV1PersistentVolumeSpec(; - accessModes=nothing, - awsElasticBlockStore=nothing, - azureDisk=nothing, - azureFile=nothing, - capacity=nothing, - cephfs=nothing, - cinder=nothing, - claimRef=nothing, - csi=nothing, - fc=nothing, - flexVolume=nothing, - flocker=nothing, - gcePersistentDisk=nothing, - glusterfs=nothing, - hostPath=nothing, - iscsi=nothing, - var"local"=nothing, - mountOptions=nothing, - nfs=nothing, - nodeAffinity=nothing, - persistentVolumeReclaimPolicy=nothing, - photonPersistentDisk=nothing, - portworxVolume=nothing, - quobyte=nothing, - rbd=nothing, - scaleIO=nothing, - storageClassName=nothing, - storageos=nothing, - volumeMode=nothing, - vsphereVolume=nothing, - ) - - - accessModes::Vector{String} : AccessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes - - awsElasticBlockStore::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - - azureDisk::IoK8sApiCoreV1AzureDiskVolumeSource - - azureFile::IoK8sApiCoreV1AzureFilePersistentVolumeSource - - capacity::Dict{String, String} : A description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity - - cephfs::IoK8sApiCoreV1CephFSPersistentVolumeSource - - cinder::IoK8sApiCoreV1CinderPersistentVolumeSource - - claimRef::IoK8sApiCoreV1ObjectReference - - csi::IoK8sApiCoreV1CSIPersistentVolumeSource - - fc::IoK8sApiCoreV1FCVolumeSource - - flexVolume::IoK8sApiCoreV1FlexPersistentVolumeSource - - flocker::IoK8sApiCoreV1FlockerVolumeSource - - gcePersistentDisk::IoK8sApiCoreV1GCEPersistentDiskVolumeSource - - glusterfs::IoK8sApiCoreV1GlusterfsPersistentVolumeSource - - hostPath::IoK8sApiCoreV1HostPathVolumeSource - - iscsi::IoK8sApiCoreV1ISCSIPersistentVolumeSource - - var"local"::IoK8sApiCoreV1LocalVolumeSource - - mountOptions::Vector{String} : A list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options - - nfs::IoK8sApiCoreV1NFSVolumeSource - - nodeAffinity::IoK8sApiCoreV1VolumeNodeAffinity - - persistentVolumeReclaimPolicy::String : What happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming - - photonPersistentDisk::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - - portworxVolume::IoK8sApiCoreV1PortworxVolumeSource - - quobyte::IoK8sApiCoreV1QuobyteVolumeSource - - rbd::IoK8sApiCoreV1RBDPersistentVolumeSource - - scaleIO::IoK8sApiCoreV1ScaleIOPersistentVolumeSource - - storageClassName::String : Name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass. - - storageos::IoK8sApiCoreV1StorageOSPersistentVolumeSource - - volumeMode::String : volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec. This is a beta feature. - - vsphereVolume::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeSpec <: OpenAPI.APIModel - accessModes::Union{Nothing, Vector{String}} = nothing - awsElasticBlockStore = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource } - azureDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AzureDiskVolumeSource } - azureFile = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AzureFilePersistentVolumeSource } - capacity::Union{Nothing, Dict{String, String}} = nothing - cephfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CephFSPersistentVolumeSource } - cinder = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CinderPersistentVolumeSource } - claimRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - csi = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CSIPersistentVolumeSource } - fc = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FCVolumeSource } - flexVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FlexPersistentVolumeSource } - flocker = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FlockerVolumeSource } - gcePersistentDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1GCEPersistentDiskVolumeSource } - glusterfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1GlusterfsPersistentVolumeSource } - hostPath = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1HostPathVolumeSource } - iscsi = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ISCSIPersistentVolumeSource } - var"local" = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalVolumeSource } - mountOptions::Union{Nothing, Vector{String}} = nothing - nfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NFSVolumeSource } - nodeAffinity = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1VolumeNodeAffinity } - persistentVolumeReclaimPolicy::Union{Nothing, String} = nothing - photonPersistentDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PhotonPersistentDiskVolumeSource } - portworxVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PortworxVolumeSource } - quobyte = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1QuobyteVolumeSource } - rbd = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1RBDPersistentVolumeSource } - scaleIO = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ScaleIOPersistentVolumeSource } - storageClassName::Union{Nothing, String} = nothing - storageos = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1StorageOSPersistentVolumeSource } - volumeMode::Union{Nothing, String} = nothing - vsphereVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1VsphereVirtualDiskVolumeSource } - - function IoK8sApiCoreV1PersistentVolumeSpec(accessModes, awsElasticBlockStore, azureDisk, azureFile, capacity, cephfs, cinder, claimRef, csi, fc, flexVolume, flocker, gcePersistentDisk, glusterfs, hostPath, iscsi, var"local", mountOptions, nfs, nodeAffinity, persistentVolumeReclaimPolicy, photonPersistentDisk, portworxVolume, quobyte, rbd, scaleIO, storageClassName, storageos, volumeMode, vsphereVolume, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("accessModes"), accessModes) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("awsElasticBlockStore"), awsElasticBlockStore) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("azureDisk"), azureDisk) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("azureFile"), azureFile) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("capacity"), capacity) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("cephfs"), cephfs) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("cinder"), cinder) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("claimRef"), claimRef) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("csi"), csi) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("fc"), fc) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("flexVolume"), flexVolume) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("flocker"), flocker) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("gcePersistentDisk"), gcePersistentDisk) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("glusterfs"), glusterfs) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("hostPath"), hostPath) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("iscsi"), iscsi) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("local"), var"local") - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("mountOptions"), mountOptions) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("nfs"), nfs) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("nodeAffinity"), nodeAffinity) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("persistentVolumeReclaimPolicy"), persistentVolumeReclaimPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("photonPersistentDisk"), photonPersistentDisk) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("portworxVolume"), portworxVolume) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("quobyte"), quobyte) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("rbd"), rbd) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("scaleIO"), scaleIO) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("storageClassName"), storageClassName) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("storageos"), storageos) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("volumeMode"), volumeMode) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeSpec, Symbol("vsphereVolume"), vsphereVolume) - return new(accessModes, awsElasticBlockStore, azureDisk, azureFile, capacity, cephfs, cinder, claimRef, csi, fc, flexVolume, flocker, gcePersistentDisk, glusterfs, hostPath, iscsi, var"local", mountOptions, nfs, nodeAffinity, persistentVolumeReclaimPolicy, photonPersistentDisk, portworxVolume, quobyte, rbd, scaleIO, storageClassName, storageos, volumeMode, vsphereVolume, ) - end -end # type IoK8sApiCoreV1PersistentVolumeSpec - -const _property_types_IoK8sApiCoreV1PersistentVolumeSpec = Dict{Symbol,String}(Symbol("accessModes")=>"Vector{String}", Symbol("awsElasticBlockStore")=>"IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource", Symbol("azureDisk")=>"IoK8sApiCoreV1AzureDiskVolumeSource", Symbol("azureFile")=>"IoK8sApiCoreV1AzureFilePersistentVolumeSource", Symbol("capacity")=>"Dict{String, String}", Symbol("cephfs")=>"IoK8sApiCoreV1CephFSPersistentVolumeSource", Symbol("cinder")=>"IoK8sApiCoreV1CinderPersistentVolumeSource", Symbol("claimRef")=>"IoK8sApiCoreV1ObjectReference", Symbol("csi")=>"IoK8sApiCoreV1CSIPersistentVolumeSource", Symbol("fc")=>"IoK8sApiCoreV1FCVolumeSource", Symbol("flexVolume")=>"IoK8sApiCoreV1FlexPersistentVolumeSource", Symbol("flocker")=>"IoK8sApiCoreV1FlockerVolumeSource", Symbol("gcePersistentDisk")=>"IoK8sApiCoreV1GCEPersistentDiskVolumeSource", Symbol("glusterfs")=>"IoK8sApiCoreV1GlusterfsPersistentVolumeSource", Symbol("hostPath")=>"IoK8sApiCoreV1HostPathVolumeSource", Symbol("iscsi")=>"IoK8sApiCoreV1ISCSIPersistentVolumeSource", Symbol("local")=>"IoK8sApiCoreV1LocalVolumeSource", Symbol("mountOptions")=>"Vector{String}", Symbol("nfs")=>"IoK8sApiCoreV1NFSVolumeSource", Symbol("nodeAffinity")=>"IoK8sApiCoreV1VolumeNodeAffinity", Symbol("persistentVolumeReclaimPolicy")=>"String", Symbol("photonPersistentDisk")=>"IoK8sApiCoreV1PhotonPersistentDiskVolumeSource", Symbol("portworxVolume")=>"IoK8sApiCoreV1PortworxVolumeSource", Symbol("quobyte")=>"IoK8sApiCoreV1QuobyteVolumeSource", Symbol("rbd")=>"IoK8sApiCoreV1RBDPersistentVolumeSource", Symbol("scaleIO")=>"IoK8sApiCoreV1ScaleIOPersistentVolumeSource", Symbol("storageClassName")=>"String", Symbol("storageos")=>"IoK8sApiCoreV1StorageOSPersistentVolumeSource", Symbol("volumeMode")=>"String", Symbol("vsphereVolume")=>"IoK8sApiCoreV1VsphereVirtualDiskVolumeSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeSpec[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeStatus.jl deleted file mode 100644 index f4b591ae..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PersistentVolumeStatus.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PersistentVolumeStatus -PersistentVolumeStatus is the current status of a persistent volume. - - IoK8sApiCoreV1PersistentVolumeStatus(; - message=nothing, - phase=nothing, - reason=nothing, - ) - - - message::String : A human-readable message indicating details about why the volume is in this state. - - phase::String : Phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase - - reason::String : Reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PersistentVolumeStatus <: OpenAPI.APIModel - message::Union{Nothing, String} = nothing - phase::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PersistentVolumeStatus(message, phase, reason, ) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeStatus, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeStatus, Symbol("phase"), phase) - OpenAPI.validate_property(IoK8sApiCoreV1PersistentVolumeStatus, Symbol("reason"), reason) - return new(message, phase, reason, ) - end -end # type IoK8sApiCoreV1PersistentVolumeStatus - -const _property_types_IoK8sApiCoreV1PersistentVolumeStatus = Dict{Symbol,String}(Symbol("message")=>"String", Symbol("phase")=>"String", Symbol("reason")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PersistentVolumeStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PersistentVolumeStatus[name]))} - -function check_required(o::IoK8sApiCoreV1PersistentVolumeStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PersistentVolumeStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource.jl deleted file mode 100644 index 3cfbef28..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource -Represents a Photon Controller persistent disk resource. - - IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(; - fsType=nothing, - pdID=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - pdID::String : ID that identifies Photon Controller persistent disk -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PhotonPersistentDiskVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - pdID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(fsType, pdID, ) - OpenAPI.validate_property(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, Symbol("pdID"), pdID) - return new(fsType, pdID, ) - end -end # type IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - -const _property_types_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("pdID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PhotonPersistentDiskVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PhotonPersistentDiskVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) - o.pdID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PhotonPersistentDiskVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Pod.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Pod.jl deleted file mode 100644 index 47ff0bb5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Pod.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Pod -Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. - - IoK8sApiCoreV1Pod(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1PodSpec - - status::IoK8sApiCoreV1PodStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Pod <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodStatus } - - function IoK8sApiCoreV1Pod(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1Pod, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Pod, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Pod, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Pod, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1Pod, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1Pod - -const _property_types_IoK8sApiCoreV1Pod = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1PodSpec", Symbol("status")=>"IoK8sApiCoreV1PodStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Pod }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Pod[name]))} - -function check_required(o::IoK8sApiCoreV1Pod) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Pod }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinity.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinity.jl deleted file mode 100644 index 1bfa376c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinity.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodAffinity -Pod affinity is a group of inter pod affinity scheduling rules. - - IoK8sApiCoreV1PodAffinity(; - preferredDuringSchedulingIgnoredDuringExecution=nothing, - requiredDuringSchedulingIgnoredDuringExecution=nothing, - ) - - - preferredDuringSchedulingIgnoredDuringExecution::Vector{IoK8sApiCoreV1WeightedPodAffinityTerm} : The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. - - requiredDuringSchedulingIgnoredDuringExecution::Vector{IoK8sApiCoreV1PodAffinityTerm} : If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodAffinity <: OpenAPI.APIModel - preferredDuringSchedulingIgnoredDuringExecution::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1WeightedPodAffinityTerm} } - requiredDuringSchedulingIgnoredDuringExecution::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodAffinityTerm} } - - function IoK8sApiCoreV1PodAffinity(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodAffinity, Symbol("preferredDuringSchedulingIgnoredDuringExecution"), preferredDuringSchedulingIgnoredDuringExecution) - OpenAPI.validate_property(IoK8sApiCoreV1PodAffinity, Symbol("requiredDuringSchedulingIgnoredDuringExecution"), requiredDuringSchedulingIgnoredDuringExecution) - return new(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - end -end # type IoK8sApiCoreV1PodAffinity - -const _property_types_IoK8sApiCoreV1PodAffinity = Dict{Symbol,String}(Symbol("preferredDuringSchedulingIgnoredDuringExecution")=>"Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}", Symbol("requiredDuringSchedulingIgnoredDuringExecution")=>"Vector{IoK8sApiCoreV1PodAffinityTerm}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodAffinity }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodAffinity[name]))} - -function check_required(o::IoK8sApiCoreV1PodAffinity) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodAffinity }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinityTerm.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinityTerm.jl deleted file mode 100644 index 3178c840..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAffinityTerm.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodAffinityTerm -Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running - - IoK8sApiCoreV1PodAffinityTerm(; - labelSelector=nothing, - namespaces=nothing, - topologyKey=nothing, - ) - - - labelSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - namespaces::Vector{String} : namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means \"this pod's namespace\" - - topologyKey::String : This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodAffinityTerm <: OpenAPI.APIModel - labelSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - namespaces::Union{Nothing, Vector{String}} = nothing - topologyKey::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PodAffinityTerm(labelSelector, namespaces, topologyKey, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodAffinityTerm, Symbol("labelSelector"), labelSelector) - OpenAPI.validate_property(IoK8sApiCoreV1PodAffinityTerm, Symbol("namespaces"), namespaces) - OpenAPI.validate_property(IoK8sApiCoreV1PodAffinityTerm, Symbol("topologyKey"), topologyKey) - return new(labelSelector, namespaces, topologyKey, ) - end -end # type IoK8sApiCoreV1PodAffinityTerm - -const _property_types_IoK8sApiCoreV1PodAffinityTerm = Dict{Symbol,String}(Symbol("labelSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("namespaces")=>"Vector{String}", Symbol("topologyKey")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodAffinityTerm }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodAffinityTerm[name]))} - -function check_required(o::IoK8sApiCoreV1PodAffinityTerm) - o.topologyKey === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodAffinityTerm }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAntiAffinity.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAntiAffinity.jl deleted file mode 100644 index da929d2b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodAntiAffinity.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodAntiAffinity -Pod anti affinity is a group of inter pod anti affinity scheduling rules. - - IoK8sApiCoreV1PodAntiAffinity(; - preferredDuringSchedulingIgnoredDuringExecution=nothing, - requiredDuringSchedulingIgnoredDuringExecution=nothing, - ) - - - preferredDuringSchedulingIgnoredDuringExecution::Vector{IoK8sApiCoreV1WeightedPodAffinityTerm} : The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. - - requiredDuringSchedulingIgnoredDuringExecution::Vector{IoK8sApiCoreV1PodAffinityTerm} : If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodAntiAffinity <: OpenAPI.APIModel - preferredDuringSchedulingIgnoredDuringExecution::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1WeightedPodAffinityTerm} } - requiredDuringSchedulingIgnoredDuringExecution::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodAffinityTerm} } - - function IoK8sApiCoreV1PodAntiAffinity(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodAntiAffinity, Symbol("preferredDuringSchedulingIgnoredDuringExecution"), preferredDuringSchedulingIgnoredDuringExecution) - OpenAPI.validate_property(IoK8sApiCoreV1PodAntiAffinity, Symbol("requiredDuringSchedulingIgnoredDuringExecution"), requiredDuringSchedulingIgnoredDuringExecution) - return new(preferredDuringSchedulingIgnoredDuringExecution, requiredDuringSchedulingIgnoredDuringExecution, ) - end -end # type IoK8sApiCoreV1PodAntiAffinity - -const _property_types_IoK8sApiCoreV1PodAntiAffinity = Dict{Symbol,String}(Symbol("preferredDuringSchedulingIgnoredDuringExecution")=>"Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}", Symbol("requiredDuringSchedulingIgnoredDuringExecution")=>"Vector{IoK8sApiCoreV1PodAffinityTerm}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodAntiAffinity }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodAntiAffinity[name]))} - -function check_required(o::IoK8sApiCoreV1PodAntiAffinity) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodAntiAffinity }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodCondition.jl deleted file mode 100644 index ef208aa2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodCondition -PodCondition contains details for the current condition of this pod. - - IoK8sApiCoreV1PodCondition(; - lastProbeTime=nothing, - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastProbeTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human-readable message indicating details about last transition. - - reason::String : Unique, one-word, CamelCase reason for the condition's last transition. - - status::String : Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions - - type::String : Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodCondition <: OpenAPI.APIModel - lastProbeTime::Union{Nothing, ZonedDateTime} = nothing - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PodCondition(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("lastProbeTime"), lastProbeTime) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1PodCondition, Symbol("type"), type) - return new(lastProbeTime, lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiCoreV1PodCondition - -const _property_types_IoK8sApiCoreV1PodCondition = Dict{Symbol,String}(Symbol("lastProbeTime")=>"ZonedDateTime", Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodCondition[name]))} - -function check_required(o::IoK8sApiCoreV1PodCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodCondition }, name::Symbol, val) - if name === Symbol("lastProbeTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodCondition", :format, val, "date-time") - end - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfig.jl deleted file mode 100644 index 4f41c38b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfig.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodDNSConfig -PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. - - IoK8sApiCoreV1PodDNSConfig(; - nameservers=nothing, - options=nothing, - searches=nothing, - ) - - - nameservers::Vector{String} : A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. - - options::Vector{IoK8sApiCoreV1PodDNSConfigOption} : A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy. - - searches::Vector{String} : A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodDNSConfig <: OpenAPI.APIModel - nameservers::Union{Nothing, Vector{String}} = nothing - options::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodDNSConfigOption} } - searches::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1PodDNSConfig(nameservers, options, searches, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodDNSConfig, Symbol("nameservers"), nameservers) - OpenAPI.validate_property(IoK8sApiCoreV1PodDNSConfig, Symbol("options"), options) - OpenAPI.validate_property(IoK8sApiCoreV1PodDNSConfig, Symbol("searches"), searches) - return new(nameservers, options, searches, ) - end -end # type IoK8sApiCoreV1PodDNSConfig - -const _property_types_IoK8sApiCoreV1PodDNSConfig = Dict{Symbol,String}(Symbol("nameservers")=>"Vector{String}", Symbol("options")=>"Vector{IoK8sApiCoreV1PodDNSConfigOption}", Symbol("searches")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodDNSConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodDNSConfig[name]))} - -function check_required(o::IoK8sApiCoreV1PodDNSConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodDNSConfig }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfigOption.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfigOption.jl deleted file mode 100644 index 6746197e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodDNSConfigOption.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodDNSConfigOption -PodDNSConfigOption defines DNS resolver options of a pod. - - IoK8sApiCoreV1PodDNSConfigOption(; - name=nothing, - value=nothing, - ) - - - name::String : Required. - - value::String -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodDNSConfigOption <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PodDNSConfigOption(name, value, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodDNSConfigOption, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1PodDNSConfigOption, Symbol("value"), value) - return new(name, value, ) - end -end # type IoK8sApiCoreV1PodDNSConfigOption - -const _property_types_IoK8sApiCoreV1PodDNSConfigOption = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodDNSConfigOption }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodDNSConfigOption[name]))} - -function check_required(o::IoK8sApiCoreV1PodDNSConfigOption) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodDNSConfigOption }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodIP.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodIP.jl deleted file mode 100644 index 37bc8c34..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodIP.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodIP -IP address information for entries in the (plural) PodIPs field. Each entry includes: IP: An IP address allocated to the pod. Routable at least within the cluster. - - IoK8sApiCoreV1PodIP(; - ip=nothing, - ) - - - ip::String : ip is an IP address (IPv4 or IPv6) assigned to the pod -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodIP <: OpenAPI.APIModel - ip::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PodIP(ip, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodIP, Symbol("ip"), ip) - return new(ip, ) - end -end # type IoK8sApiCoreV1PodIP - -const _property_types_IoK8sApiCoreV1PodIP = Dict{Symbol,String}(Symbol("ip")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodIP }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodIP[name]))} - -function check_required(o::IoK8sApiCoreV1PodIP) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodIP }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodList.jl deleted file mode 100644 index 2484f0d5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodList -PodList is a list of Pods. - - IoK8sApiCoreV1PodList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Pod} : List of pods. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Pod} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1PodList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PodList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1PodList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PodList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1PodList - -const _property_types_IoK8sApiCoreV1PodList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Pod}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodList[name]))} - -function check_required(o::IoK8sApiCoreV1PodList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodReadinessGate.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodReadinessGate.jl deleted file mode 100644 index d108dd67..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodReadinessGate.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodReadinessGate -PodReadinessGate contains the reference to a pod condition - - IoK8sApiCoreV1PodReadinessGate(; - conditionType=nothing, - ) - - - conditionType::String : ConditionType refers to a condition in the pod's condition list with matching type. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodReadinessGate <: OpenAPI.APIModel - conditionType::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PodReadinessGate(conditionType, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodReadinessGate, Symbol("conditionType"), conditionType) - return new(conditionType, ) - end -end # type IoK8sApiCoreV1PodReadinessGate - -const _property_types_IoK8sApiCoreV1PodReadinessGate = Dict{Symbol,String}(Symbol("conditionType")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodReadinessGate }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodReadinessGate[name]))} - -function check_required(o::IoK8sApiCoreV1PodReadinessGate) - o.conditionType === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodReadinessGate }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSecurityContext.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSecurityContext.jl deleted file mode 100644 index 9bb89d4c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSecurityContext.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodSecurityContext -PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. - - IoK8sApiCoreV1PodSecurityContext(; - fsGroup=nothing, - runAsGroup=nothing, - runAsNonRoot=nothing, - runAsUser=nothing, - seLinuxOptions=nothing, - supplementalGroups=nothing, - sysctls=nothing, - windowsOptions=nothing, - ) - - - fsGroup::Int64 : A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- If unset, the Kubelet will not modify the ownership and permissions of any volume. - - runAsGroup::Int64 : The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. - - runAsNonRoot::Bool : Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. - - runAsUser::Int64 : The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. - - seLinuxOptions::IoK8sApiCoreV1SELinuxOptions - - supplementalGroups::Vector{Int64} : A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. - - sysctls::Vector{IoK8sApiCoreV1Sysctl} : Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. - - windowsOptions::IoK8sApiCoreV1WindowsSecurityContextOptions -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodSecurityContext <: OpenAPI.APIModel - fsGroup::Union{Nothing, Int64} = nothing - runAsGroup::Union{Nothing, Int64} = nothing - runAsNonRoot::Union{Nothing, Bool} = nothing - runAsUser::Union{Nothing, Int64} = nothing - seLinuxOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SELinuxOptions } - supplementalGroups::Union{Nothing, Vector{Int64}} = nothing - sysctls::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Sysctl} } - windowsOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1WindowsSecurityContextOptions } - - function IoK8sApiCoreV1PodSecurityContext(fsGroup, runAsGroup, runAsNonRoot, runAsUser, seLinuxOptions, supplementalGroups, sysctls, windowsOptions, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("fsGroup"), fsGroup) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("runAsGroup"), runAsGroup) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("runAsNonRoot"), runAsNonRoot) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("runAsUser"), runAsUser) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("seLinuxOptions"), seLinuxOptions) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("supplementalGroups"), supplementalGroups) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("sysctls"), sysctls) - OpenAPI.validate_property(IoK8sApiCoreV1PodSecurityContext, Symbol("windowsOptions"), windowsOptions) - return new(fsGroup, runAsGroup, runAsNonRoot, runAsUser, seLinuxOptions, supplementalGroups, sysctls, windowsOptions, ) - end -end # type IoK8sApiCoreV1PodSecurityContext - -const _property_types_IoK8sApiCoreV1PodSecurityContext = Dict{Symbol,String}(Symbol("fsGroup")=>"Int64", Symbol("runAsGroup")=>"Int64", Symbol("runAsNonRoot")=>"Bool", Symbol("runAsUser")=>"Int64", Symbol("seLinuxOptions")=>"IoK8sApiCoreV1SELinuxOptions", Symbol("supplementalGroups")=>"Vector{Int64}", Symbol("sysctls")=>"Vector{IoK8sApiCoreV1Sysctl}", Symbol("windowsOptions")=>"IoK8sApiCoreV1WindowsSecurityContextOptions", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodSecurityContext }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodSecurityContext[name]))} - -function check_required(o::IoK8sApiCoreV1PodSecurityContext) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodSecurityContext }, name::Symbol, val) - if name === Symbol("fsGroup") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSecurityContext", :format, val, "int64") - end - if name === Symbol("runAsGroup") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSecurityContext", :format, val, "int64") - end - if name === Symbol("runAsUser") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSecurityContext", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSpec.jl deleted file mode 100644 index 18397d38..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodSpec.jl +++ /dev/null @@ -1,173 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodSpec -PodSpec is a description of a pod. - - IoK8sApiCoreV1PodSpec(; - activeDeadlineSeconds=nothing, - affinity=nothing, - automountServiceAccountToken=nothing, - containers=nothing, - dnsConfig=nothing, - dnsPolicy=nothing, - enableServiceLinks=nothing, - ephemeralContainers=nothing, - hostAliases=nothing, - hostIPC=nothing, - hostNetwork=nothing, - hostPID=nothing, - hostname=nothing, - imagePullSecrets=nothing, - initContainers=nothing, - nodeName=nothing, - nodeSelector=nothing, - overhead=nothing, - preemptionPolicy=nothing, - priority=nothing, - priorityClassName=nothing, - readinessGates=nothing, - restartPolicy=nothing, - runtimeClassName=nothing, - schedulerName=nothing, - securityContext=nothing, - serviceAccount=nothing, - serviceAccountName=nothing, - shareProcessNamespace=nothing, - subdomain=nothing, - terminationGracePeriodSeconds=nothing, - tolerations=nothing, - topologySpreadConstraints=nothing, - volumes=nothing, - ) - - - activeDeadlineSeconds::Int64 : Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer. - - affinity::IoK8sApiCoreV1Affinity - - automountServiceAccountToken::Bool : AutomountServiceAccountToken indicates whether a service account token should be automatically mounted. - - containers::Vector{IoK8sApiCoreV1Container} : List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated. - - dnsConfig::IoK8sApiCoreV1PodDNSConfig - - dnsPolicy::String : Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'. - - enableServiceLinks::Bool : EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true. - - ephemeralContainers::Vector{IoK8sApiCoreV1EphemeralContainer} : List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. - - hostAliases::Vector{IoK8sApiCoreV1HostAlias} : HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified. This is only valid for non-hostNetwork pods. - - hostIPC::Bool : Use the host's ipc namespace. Optional: Default to false. - - hostNetwork::Bool : Host networking requested for this pod. Use the host's network namespace. If this option is set, the ports that will be used must be specified. Default to false. - - hostPID::Bool : Use the host's pid namespace. Optional: Default to false. - - hostname::String : Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value. - - imagePullSecrets::Vector{IoK8sApiCoreV1LocalObjectReference} : ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. For example, in the case of docker, only DockerConfig type secrets are honored. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod - - initContainers::Vector{IoK8sApiCoreV1Container} : List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/ - - nodeName::String : NodeName is a request to schedule this pod onto a specific node. If it is non-empty, the scheduler simply schedules this pod onto that node, assuming that it fits resource requirements. - - nodeSelector::Dict{String, String} : NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/ - - overhead::Dict{String, String} : Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/20190226-pod-overhead.md This field is alpha-level as of Kubernetes v1.16, and is only honored by servers that enable the PodOverhead feature. - - preemptionPolicy::String : PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. - - priority::Int64 : The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. - - priorityClassName::String : If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default. - - readinessGates::Vector{IoK8sApiCoreV1PodReadinessGate} : If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/0007-pod-ready%2B%2B.md - - restartPolicy::String : Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy - - runtimeClassName::String : RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md This is a beta feature as of Kubernetes v1.14. - - schedulerName::String : If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler. - - securityContext::IoK8sApiCoreV1PodSecurityContext - - serviceAccount::String : DeprecatedServiceAccount is a depreciated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead. - - serviceAccountName::String : ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ - - shareProcessNamespace::Bool : Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false. - - subdomain::String : If specified, the fully qualified Pod hostname will be \"<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>\". If not specified, the pod will not have a domainname at all. - - terminationGracePeriodSeconds::Int64 : Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds. - - tolerations::Vector{IoK8sApiCoreV1Toleration} : If specified, the pod's tolerations. - - topologySpreadConstraints::Vector{IoK8sApiCoreV1TopologySpreadConstraint} : TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. This field is alpha-level and is only honored by clusters that enables the EvenPodsSpread feature. All topologySpreadConstraints are ANDed. - - volumes::Vector{IoK8sApiCoreV1Volume} : List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodSpec <: OpenAPI.APIModel - activeDeadlineSeconds::Union{Nothing, Int64} = nothing - affinity = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Affinity } - automountServiceAccountToken::Union{Nothing, Bool} = nothing - containers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Container} } - dnsConfig = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodDNSConfig } - dnsPolicy::Union{Nothing, String} = nothing - enableServiceLinks::Union{Nothing, Bool} = nothing - ephemeralContainers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EphemeralContainer} } - hostAliases::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1HostAlias} } - hostIPC::Union{Nothing, Bool} = nothing - hostNetwork::Union{Nothing, Bool} = nothing - hostPID::Union{Nothing, Bool} = nothing - hostname::Union{Nothing, String} = nothing - imagePullSecrets::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1LocalObjectReference} } - initContainers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Container} } - nodeName::Union{Nothing, String} = nothing - nodeSelector::Union{Nothing, Dict{String, String}} = nothing - overhead::Union{Nothing, Dict{String, String}} = nothing - preemptionPolicy::Union{Nothing, String} = nothing - priority::Union{Nothing, Int64} = nothing - priorityClassName::Union{Nothing, String} = nothing - readinessGates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodReadinessGate} } - restartPolicy::Union{Nothing, String} = nothing - runtimeClassName::Union{Nothing, String} = nothing - schedulerName::Union{Nothing, String} = nothing - securityContext = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodSecurityContext } - serviceAccount::Union{Nothing, String} = nothing - serviceAccountName::Union{Nothing, String} = nothing - shareProcessNamespace::Union{Nothing, Bool} = nothing - subdomain::Union{Nothing, String} = nothing - terminationGracePeriodSeconds::Union{Nothing, Int64} = nothing - tolerations::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Toleration} } - topologySpreadConstraints::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1TopologySpreadConstraint} } - volumes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Volume} } - - function IoK8sApiCoreV1PodSpec(activeDeadlineSeconds, affinity, automountServiceAccountToken, containers, dnsConfig, dnsPolicy, enableServiceLinks, ephemeralContainers, hostAliases, hostIPC, hostNetwork, hostPID, hostname, imagePullSecrets, initContainers, nodeName, nodeSelector, overhead, preemptionPolicy, priority, priorityClassName, readinessGates, restartPolicy, runtimeClassName, schedulerName, securityContext, serviceAccount, serviceAccountName, shareProcessNamespace, subdomain, terminationGracePeriodSeconds, tolerations, topologySpreadConstraints, volumes, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("activeDeadlineSeconds"), activeDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("affinity"), affinity) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("automountServiceAccountToken"), automountServiceAccountToken) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("containers"), containers) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("dnsConfig"), dnsConfig) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("dnsPolicy"), dnsPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("enableServiceLinks"), enableServiceLinks) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("ephemeralContainers"), ephemeralContainers) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("hostAliases"), hostAliases) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("hostIPC"), hostIPC) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("hostNetwork"), hostNetwork) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("hostPID"), hostPID) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("hostname"), hostname) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("imagePullSecrets"), imagePullSecrets) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("initContainers"), initContainers) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("nodeName"), nodeName) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("nodeSelector"), nodeSelector) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("overhead"), overhead) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("preemptionPolicy"), preemptionPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("priority"), priority) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("priorityClassName"), priorityClassName) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("readinessGates"), readinessGates) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("restartPolicy"), restartPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("runtimeClassName"), runtimeClassName) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("schedulerName"), schedulerName) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("securityContext"), securityContext) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("serviceAccount"), serviceAccount) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("serviceAccountName"), serviceAccountName) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("shareProcessNamespace"), shareProcessNamespace) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("subdomain"), subdomain) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("terminationGracePeriodSeconds"), terminationGracePeriodSeconds) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("tolerations"), tolerations) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("topologySpreadConstraints"), topologySpreadConstraints) - OpenAPI.validate_property(IoK8sApiCoreV1PodSpec, Symbol("volumes"), volumes) - return new(activeDeadlineSeconds, affinity, automountServiceAccountToken, containers, dnsConfig, dnsPolicy, enableServiceLinks, ephemeralContainers, hostAliases, hostIPC, hostNetwork, hostPID, hostname, imagePullSecrets, initContainers, nodeName, nodeSelector, overhead, preemptionPolicy, priority, priorityClassName, readinessGates, restartPolicy, runtimeClassName, schedulerName, securityContext, serviceAccount, serviceAccountName, shareProcessNamespace, subdomain, terminationGracePeriodSeconds, tolerations, topologySpreadConstraints, volumes, ) - end -end # type IoK8sApiCoreV1PodSpec - -const _property_types_IoK8sApiCoreV1PodSpec = Dict{Symbol,String}(Symbol("activeDeadlineSeconds")=>"Int64", Symbol("affinity")=>"IoK8sApiCoreV1Affinity", Symbol("automountServiceAccountToken")=>"Bool", Symbol("containers")=>"Vector{IoK8sApiCoreV1Container}", Symbol("dnsConfig")=>"IoK8sApiCoreV1PodDNSConfig", Symbol("dnsPolicy")=>"String", Symbol("enableServiceLinks")=>"Bool", Symbol("ephemeralContainers")=>"Vector{IoK8sApiCoreV1EphemeralContainer}", Symbol("hostAliases")=>"Vector{IoK8sApiCoreV1HostAlias}", Symbol("hostIPC")=>"Bool", Symbol("hostNetwork")=>"Bool", Symbol("hostPID")=>"Bool", Symbol("hostname")=>"String", Symbol("imagePullSecrets")=>"Vector{IoK8sApiCoreV1LocalObjectReference}", Symbol("initContainers")=>"Vector{IoK8sApiCoreV1Container}", Symbol("nodeName")=>"String", Symbol("nodeSelector")=>"Dict{String, String}", Symbol("overhead")=>"Dict{String, String}", Symbol("preemptionPolicy")=>"String", Symbol("priority")=>"Int64", Symbol("priorityClassName")=>"String", Symbol("readinessGates")=>"Vector{IoK8sApiCoreV1PodReadinessGate}", Symbol("restartPolicy")=>"String", Symbol("runtimeClassName")=>"String", Symbol("schedulerName")=>"String", Symbol("securityContext")=>"IoK8sApiCoreV1PodSecurityContext", Symbol("serviceAccount")=>"String", Symbol("serviceAccountName")=>"String", Symbol("shareProcessNamespace")=>"Bool", Symbol("subdomain")=>"String", Symbol("terminationGracePeriodSeconds")=>"Int64", Symbol("tolerations")=>"Vector{IoK8sApiCoreV1Toleration}", Symbol("topologySpreadConstraints")=>"Vector{IoK8sApiCoreV1TopologySpreadConstraint}", Symbol("volumes")=>"Vector{IoK8sApiCoreV1Volume}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodSpec[name]))} - -function check_required(o::IoK8sApiCoreV1PodSpec) - o.containers === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodSpec }, name::Symbol, val) - if name === Symbol("activeDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSpec", :format, val, "int64") - end - if name === Symbol("priority") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSpec", :format, val, "int32") - end - if name === Symbol("terminationGracePeriodSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodSpec", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodStatus.jl deleted file mode 100644 index c61a4b85..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodStatus.jl +++ /dev/null @@ -1,82 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodStatus -PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane. - - IoK8sApiCoreV1PodStatus(; - conditions=nothing, - containerStatuses=nothing, - ephemeralContainerStatuses=nothing, - hostIP=nothing, - initContainerStatuses=nothing, - message=nothing, - nominatedNodeName=nothing, - phase=nothing, - podIP=nothing, - podIPs=nothing, - qosClass=nothing, - reason=nothing, - startTime=nothing, - ) - - - conditions::Vector{IoK8sApiCoreV1PodCondition} : Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions - - containerStatuses::Vector{IoK8sApiCoreV1ContainerStatus} : The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status - - ephemeralContainerStatuses::Vector{IoK8sApiCoreV1ContainerStatus} : Status for any ephemeral containers that have run in this pod. This field is alpha-level and is only populated by servers that enable the EphemeralContainers feature. - - hostIP::String : IP address of the host to which the pod is assigned. Empty if not yet scheduled. - - initContainerStatuses::Vector{IoK8sApiCoreV1ContainerStatus} : The list has one entry per init container in the manifest. The most recent successful init container will have ready = true, the most recently started container will have startTime set. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status - - message::String : A human readable message indicating details about why the pod is in this condition. - - nominatedNodeName::String : nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled. - - phase::String : The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values: Pending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase - - podIP::String : IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated. - - podIPs::Vector{IoK8sApiCoreV1PodIP} : podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet. - - qosClass::String : The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://git.k8s.io/community/contributors/design-proposals/node/resource-qos.md - - reason::String : A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted' - - startTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodCondition} } - containerStatuses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerStatus} } - ephemeralContainerStatuses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerStatus} } - hostIP::Union{Nothing, String} = nothing - initContainerStatuses::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ContainerStatus} } - message::Union{Nothing, String} = nothing - nominatedNodeName::Union{Nothing, String} = nothing - phase::Union{Nothing, String} = nothing - podIP::Union{Nothing, String} = nothing - podIPs::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodIP} } - qosClass::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - startTime::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiCoreV1PodStatus(conditions, containerStatuses, ephemeralContainerStatuses, hostIP, initContainerStatuses, message, nominatedNodeName, phase, podIP, podIPs, qosClass, reason, startTime, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("containerStatuses"), containerStatuses) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("ephemeralContainerStatuses"), ephemeralContainerStatuses) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("hostIP"), hostIP) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("initContainerStatuses"), initContainerStatuses) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("nominatedNodeName"), nominatedNodeName) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("phase"), phase) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("podIP"), podIP) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("podIPs"), podIPs) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("qosClass"), qosClass) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1PodStatus, Symbol("startTime"), startTime) - return new(conditions, containerStatuses, ephemeralContainerStatuses, hostIP, initContainerStatuses, message, nominatedNodeName, phase, podIP, podIPs, qosClass, reason, startTime, ) - end -end # type IoK8sApiCoreV1PodStatus - -const _property_types_IoK8sApiCoreV1PodStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiCoreV1PodCondition}", Symbol("containerStatuses")=>"Vector{IoK8sApiCoreV1ContainerStatus}", Symbol("ephemeralContainerStatuses")=>"Vector{IoK8sApiCoreV1ContainerStatus}", Symbol("hostIP")=>"String", Symbol("initContainerStatuses")=>"Vector{IoK8sApiCoreV1ContainerStatus}", Symbol("message")=>"String", Symbol("nominatedNodeName")=>"String", Symbol("phase")=>"String", Symbol("podIP")=>"String", Symbol("podIPs")=>"Vector{IoK8sApiCoreV1PodIP}", Symbol("qosClass")=>"String", Symbol("reason")=>"String", Symbol("startTime")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodStatus[name]))} - -function check_required(o::IoK8sApiCoreV1PodStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodStatus }, name::Symbol, val) - if name === Symbol("startTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PodStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplate.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplate.jl deleted file mode 100644 index 5cd8fed5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplate.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodTemplate -PodTemplate describes a template for creating copies of a predefined pod. - - IoK8sApiCoreV1PodTemplate(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - template=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodTemplate <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiCoreV1PodTemplate(apiVersion, kind, metadata, template, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplate, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplate, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplate, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplate, Symbol("template"), template) - return new(apiVersion, kind, metadata, template, ) - end -end # type IoK8sApiCoreV1PodTemplate - -const _property_types_IoK8sApiCoreV1PodTemplate = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodTemplate }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodTemplate[name]))} - -function check_required(o::IoK8sApiCoreV1PodTemplate) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodTemplate }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateList.jl deleted file mode 100644 index 3dbb1a71..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodTemplateList -PodTemplateList is a list of PodTemplates. - - IoK8sApiCoreV1PodTemplateList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1PodTemplate} : List of pod templates - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodTemplateList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1PodTemplate} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1PodTemplateList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1PodTemplateList - -const _property_types_IoK8sApiCoreV1PodTemplateList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1PodTemplate}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodTemplateList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodTemplateList[name]))} - -function check_required(o::IoK8sApiCoreV1PodTemplateList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodTemplateList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateSpec.jl deleted file mode 100644 index 1c67f442..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PodTemplateSpec.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PodTemplateSpec -PodTemplateSpec describes the data a pod should have when created from a template - - IoK8sApiCoreV1PodTemplateSpec(; - metadata=nothing, - spec=nothing, - ) - - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1PodSpec -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PodTemplateSpec <: OpenAPI.APIModel - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodSpec } - - function IoK8sApiCoreV1PodTemplateSpec(metadata, spec, ) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateSpec, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1PodTemplateSpec, Symbol("spec"), spec) - return new(metadata, spec, ) - end -end # type IoK8sApiCoreV1PodTemplateSpec - -const _property_types_IoK8sApiCoreV1PodTemplateSpec = Dict{Symbol,String}(Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1PodSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PodTemplateSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PodTemplateSpec[name]))} - -function check_required(o::IoK8sApiCoreV1PodTemplateSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PodTemplateSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PortworxVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PortworxVolumeSource.jl deleted file mode 100644 index 5ca610aa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PortworxVolumeSource.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PortworxVolumeSource -PortworxVolumeSource represents a Portworx volume resource. - - IoK8sApiCoreV1PortworxVolumeSource(; - fsType=nothing, - readOnly=nothing, - volumeID=nothing, - ) - - - fsType::String : FSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified. - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - volumeID::String : VolumeID uniquely identifies a Portworx volume -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PortworxVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - volumeID::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1PortworxVolumeSource(fsType, readOnly, volumeID, ) - OpenAPI.validate_property(IoK8sApiCoreV1PortworxVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1PortworxVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1PortworxVolumeSource, Symbol("volumeID"), volumeID) - return new(fsType, readOnly, volumeID, ) - end -end # type IoK8sApiCoreV1PortworxVolumeSource - -const _property_types_IoK8sApiCoreV1PortworxVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("readOnly")=>"Bool", Symbol("volumeID")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PortworxVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PortworxVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1PortworxVolumeSource) - o.volumeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PortworxVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PreferredSchedulingTerm.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1PreferredSchedulingTerm.jl deleted file mode 100644 index bef050b2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1PreferredSchedulingTerm.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.PreferredSchedulingTerm -An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). - - IoK8sApiCoreV1PreferredSchedulingTerm(; - preference=nothing, - weight=nothing, - ) - - - preference::IoK8sApiCoreV1NodeSelectorTerm - - weight::Int64 : Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1PreferredSchedulingTerm <: OpenAPI.APIModel - preference = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeSelectorTerm } - weight::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1PreferredSchedulingTerm(preference, weight, ) - OpenAPI.validate_property(IoK8sApiCoreV1PreferredSchedulingTerm, Symbol("preference"), preference) - OpenAPI.validate_property(IoK8sApiCoreV1PreferredSchedulingTerm, Symbol("weight"), weight) - return new(preference, weight, ) - end -end # type IoK8sApiCoreV1PreferredSchedulingTerm - -const _property_types_IoK8sApiCoreV1PreferredSchedulingTerm = Dict{Symbol,String}(Symbol("preference")=>"IoK8sApiCoreV1NodeSelectorTerm", Symbol("weight")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1PreferredSchedulingTerm }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1PreferredSchedulingTerm[name]))} - -function check_required(o::IoK8sApiCoreV1PreferredSchedulingTerm) - o.preference === nothing && (return false) - o.weight === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1PreferredSchedulingTerm }, name::Symbol, val) - if name === Symbol("weight") - OpenAPI.validate_param(name, "IoK8sApiCoreV1PreferredSchedulingTerm", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Probe.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Probe.jl deleted file mode 100644 index b871a94c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Probe.jl +++ /dev/null @@ -1,74 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Probe -Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic. - - IoK8sApiCoreV1Probe(; - exec=nothing, - failureThreshold=nothing, - httpGet=nothing, - initialDelaySeconds=nothing, - periodSeconds=nothing, - successThreshold=nothing, - tcpSocket=nothing, - timeoutSeconds=nothing, - ) - - - exec::IoK8sApiCoreV1ExecAction - - failureThreshold::Int64 : Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. - - httpGet::IoK8sApiCoreV1HTTPGetAction - - initialDelaySeconds::Int64 : Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes - - periodSeconds::Int64 : How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. - - successThreshold::Int64 : Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. - - tcpSocket::IoK8sApiCoreV1TCPSocketAction - - timeoutSeconds::Int64 : Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Probe <: OpenAPI.APIModel - exec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ExecAction } - failureThreshold::Union{Nothing, Int64} = nothing - httpGet = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1HTTPGetAction } - initialDelaySeconds::Union{Nothing, Int64} = nothing - periodSeconds::Union{Nothing, Int64} = nothing - successThreshold::Union{Nothing, Int64} = nothing - tcpSocket = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1TCPSocketAction } - timeoutSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1Probe(exec, failureThreshold, httpGet, initialDelaySeconds, periodSeconds, successThreshold, tcpSocket, timeoutSeconds, ) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("exec"), exec) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("failureThreshold"), failureThreshold) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("httpGet"), httpGet) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("initialDelaySeconds"), initialDelaySeconds) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("periodSeconds"), periodSeconds) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("successThreshold"), successThreshold) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("tcpSocket"), tcpSocket) - OpenAPI.validate_property(IoK8sApiCoreV1Probe, Symbol("timeoutSeconds"), timeoutSeconds) - return new(exec, failureThreshold, httpGet, initialDelaySeconds, periodSeconds, successThreshold, tcpSocket, timeoutSeconds, ) - end -end # type IoK8sApiCoreV1Probe - -const _property_types_IoK8sApiCoreV1Probe = Dict{Symbol,String}(Symbol("exec")=>"IoK8sApiCoreV1ExecAction", Symbol("failureThreshold")=>"Int64", Symbol("httpGet")=>"IoK8sApiCoreV1HTTPGetAction", Symbol("initialDelaySeconds")=>"Int64", Symbol("periodSeconds")=>"Int64", Symbol("successThreshold")=>"Int64", Symbol("tcpSocket")=>"IoK8sApiCoreV1TCPSocketAction", Symbol("timeoutSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Probe }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Probe[name]))} - -function check_required(o::IoK8sApiCoreV1Probe) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Probe }, name::Symbol, val) - if name === Symbol("failureThreshold") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Probe", :format, val, "int32") - end - if name === Symbol("initialDelaySeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Probe", :format, val, "int32") - end - if name === Symbol("periodSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Probe", :format, val, "int32") - end - if name === Symbol("successThreshold") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Probe", :format, val, "int32") - end - if name === Symbol("timeoutSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Probe", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ProjectedVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ProjectedVolumeSource.jl deleted file mode 100644 index fb096ac3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ProjectedVolumeSource.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ProjectedVolumeSource -Represents a projected volume source - - IoK8sApiCoreV1ProjectedVolumeSource(; - defaultMode=nothing, - sources=nothing, - ) - - - defaultMode::Int64 : Mode bits to use on created files by default. Must be a value between 0 and 0777. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - sources::Vector{IoK8sApiCoreV1VolumeProjection} : list of volume projections -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ProjectedVolumeSource <: OpenAPI.APIModel - defaultMode::Union{Nothing, Int64} = nothing - sources::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeProjection} } - - function IoK8sApiCoreV1ProjectedVolumeSource(defaultMode, sources, ) - OpenAPI.validate_property(IoK8sApiCoreV1ProjectedVolumeSource, Symbol("defaultMode"), defaultMode) - OpenAPI.validate_property(IoK8sApiCoreV1ProjectedVolumeSource, Symbol("sources"), sources) - return new(defaultMode, sources, ) - end -end # type IoK8sApiCoreV1ProjectedVolumeSource - -const _property_types_IoK8sApiCoreV1ProjectedVolumeSource = Dict{Symbol,String}(Symbol("defaultMode")=>"Int64", Symbol("sources")=>"Vector{IoK8sApiCoreV1VolumeProjection}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ProjectedVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ProjectedVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ProjectedVolumeSource) - o.sources === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ProjectedVolumeSource }, name::Symbol, val) - if name === Symbol("defaultMode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ProjectedVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1QuobyteVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1QuobyteVolumeSource.jl deleted file mode 100644 index 54478cb1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1QuobyteVolumeSource.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.QuobyteVolumeSource -Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling. - - IoK8sApiCoreV1QuobyteVolumeSource(; - group=nothing, - readOnly=nothing, - registry=nothing, - tenant=nothing, - user=nothing, - volume=nothing, - ) - - - group::String : Group to map volume access to Default is no group - - readOnly::Bool : ReadOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false. - - registry::String : Registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes - - tenant::String : Tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin - - user::String : User to map volume access to Defaults to serivceaccount user - - volume::String : Volume is a string that references an already created Quobyte volume by name. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1QuobyteVolumeSource <: OpenAPI.APIModel - group::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - registry::Union{Nothing, String} = nothing - tenant::Union{Nothing, String} = nothing - user::Union{Nothing, String} = nothing - volume::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1QuobyteVolumeSource(group, readOnly, registry, tenant, user, volume, ) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("registry"), registry) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("tenant"), tenant) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("user"), user) - OpenAPI.validate_property(IoK8sApiCoreV1QuobyteVolumeSource, Symbol("volume"), volume) - return new(group, readOnly, registry, tenant, user, volume, ) - end -end # type IoK8sApiCoreV1QuobyteVolumeSource - -const _property_types_IoK8sApiCoreV1QuobyteVolumeSource = Dict{Symbol,String}(Symbol("group")=>"String", Symbol("readOnly")=>"Bool", Symbol("registry")=>"String", Symbol("tenant")=>"String", Symbol("user")=>"String", Symbol("volume")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1QuobyteVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1QuobyteVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1QuobyteVolumeSource) - o.registry === nothing && (return false) - o.volume === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1QuobyteVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDPersistentVolumeSource.jl deleted file mode 100644 index 86439791..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDPersistentVolumeSource.jl +++ /dev/null @@ -1,61 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.RBDPersistentVolumeSource -Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1RBDPersistentVolumeSource(; - fsType=nothing, - image=nothing, - keyring=nothing, - monitors=nothing, - pool=nothing, - readOnly=nothing, - secretRef=nothing, - user=nothing, - ) - - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd - - image::String : The rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - keyring::String : Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - monitors::Vector{String} : A collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - pool::String : The rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - readOnly::Bool : ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - secretRef::IoK8sApiCoreV1SecretReference - - user::String : The rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it -""" -Base.@kwdef mutable struct IoK8sApiCoreV1RBDPersistentVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - image::Union{Nothing, String} = nothing - keyring::Union{Nothing, String} = nothing - monitors::Union{Nothing, Vector{String}} = nothing - pool::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - user::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1RBDPersistentVolumeSource(fsType, image, keyring, monitors, pool, readOnly, secretRef, user, ) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("image"), image) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("keyring"), keyring) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("monitors"), monitors) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("pool"), pool) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1RBDPersistentVolumeSource, Symbol("user"), user) - return new(fsType, image, keyring, monitors, pool, readOnly, secretRef, user, ) - end -end # type IoK8sApiCoreV1RBDPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1RBDPersistentVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("image")=>"String", Symbol("keyring")=>"String", Symbol("monitors")=>"Vector{String}", Symbol("pool")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1RBDPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1RBDPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1RBDPersistentVolumeSource) - o.image === nothing && (return false) - o.monitors === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1RBDPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDVolumeSource.jl deleted file mode 100644 index 5b9fb9d6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1RBDVolumeSource.jl +++ /dev/null @@ -1,61 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.RBDVolumeSource -Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1RBDVolumeSource(; - fsType=nothing, - image=nothing, - keyring=nothing, - monitors=nothing, - pool=nothing, - readOnly=nothing, - secretRef=nothing, - user=nothing, - ) - - - fsType::String : Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd - - image::String : The rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - keyring::String : Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - monitors::Vector{String} : A collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - pool::String : The rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - readOnly::Bool : ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it - - secretRef::IoK8sApiCoreV1LocalObjectReference - - user::String : The rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it -""" -Base.@kwdef mutable struct IoK8sApiCoreV1RBDVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - image::Union{Nothing, String} = nothing - keyring::Union{Nothing, String} = nothing - monitors::Union{Nothing, Vector{String}} = nothing - pool::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - user::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1RBDVolumeSource(fsType, image, keyring, monitors, pool, readOnly, secretRef, user, ) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("image"), image) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("keyring"), keyring) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("monitors"), monitors) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("pool"), pool) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1RBDVolumeSource, Symbol("user"), user) - return new(fsType, image, keyring, monitors, pool, readOnly, secretRef, user, ) - end -end # type IoK8sApiCoreV1RBDVolumeSource - -const _property_types_IoK8sApiCoreV1RBDVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("image")=>"String", Symbol("keyring")=>"String", Symbol("monitors")=>"Vector{String}", Symbol("pool")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1RBDVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1RBDVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1RBDVolumeSource) - o.image === nothing && (return false) - o.monitors === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1RBDVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationController.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationController.jl deleted file mode 100644 index 7f00af5b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationController.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ReplicationController -ReplicationController represents the configuration of a replication controller. - - IoK8sApiCoreV1ReplicationController(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1ReplicationControllerSpec - - status::IoK8sApiCoreV1ReplicationControllerStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ReplicationController <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ReplicationControllerSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ReplicationControllerStatus } - - function IoK8sApiCoreV1ReplicationController(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationController, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationController, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationController, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationController, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationController, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1ReplicationController - -const _property_types_IoK8sApiCoreV1ReplicationController = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1ReplicationControllerSpec", Symbol("status")=>"IoK8sApiCoreV1ReplicationControllerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ReplicationController }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ReplicationController[name]))} - -function check_required(o::IoK8sApiCoreV1ReplicationController) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ReplicationController }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerCondition.jl deleted file mode 100644 index ff661703..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ReplicationControllerCondition -ReplicationControllerCondition describes the state of a replication controller at a certain point. - - IoK8sApiCoreV1ReplicationControllerCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of replication controller condition. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ReplicationControllerCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ReplicationControllerCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiCoreV1ReplicationControllerCondition - -const _property_types_IoK8sApiCoreV1ReplicationControllerCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ReplicationControllerCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ReplicationControllerCondition[name]))} - -function check_required(o::IoK8sApiCoreV1ReplicationControllerCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ReplicationControllerCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerList.jl deleted file mode 100644 index 51281e6a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ReplicationControllerList -ReplicationControllerList is a collection of replication controllers. - - IoK8sApiCoreV1ReplicationControllerList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1ReplicationController} : List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ReplicationControllerList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ReplicationController} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ReplicationControllerList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ReplicationControllerList - -const _property_types_IoK8sApiCoreV1ReplicationControllerList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1ReplicationController}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ReplicationControllerList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ReplicationControllerList[name]))} - -function check_required(o::IoK8sApiCoreV1ReplicationControllerList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ReplicationControllerList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerSpec.jl deleted file mode 100644 index bb6d7f3e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerSpec.jl +++ /dev/null @@ -1,49 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ReplicationControllerSpec -ReplicationControllerSpec is the specification of a replication controller. - - IoK8sApiCoreV1ReplicationControllerSpec(; - minReadySeconds=nothing, - replicas=nothing, - selector=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - replicas::Int64 : Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller - - selector::Dict{String, String} : Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ReplicationControllerSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - selector::Union{Nothing, Dict{String, String}} = nothing - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiCoreV1ReplicationControllerSpec(minReadySeconds, replicas, selector, template, ) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerSpec, Symbol("template"), template) - return new(minReadySeconds, replicas, selector, template, ) - end -end # type IoK8sApiCoreV1ReplicationControllerSpec - -const _property_types_IoK8sApiCoreV1ReplicationControllerSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("selector")=>"Dict{String, String}", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ReplicationControllerSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ReplicationControllerSpec[name]))} - -function check_required(o::IoK8sApiCoreV1ReplicationControllerSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ReplicationControllerSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerStatus.jl deleted file mode 100644 index cb23a2d6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ReplicationControllerStatus.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ReplicationControllerStatus -ReplicationControllerStatus represents the current status of a replication controller. - - IoK8sApiCoreV1ReplicationControllerStatus(; - availableReplicas=nothing, - conditions=nothing, - fullyLabeledReplicas=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - ) - - - availableReplicas::Int64 : The number of available replicas (ready for at least minReadySeconds) for this replication controller. - - conditions::Vector{IoK8sApiCoreV1ReplicationControllerCondition} : Represents the latest available observations of a replication controller's current state. - - fullyLabeledReplicas::Int64 : The number of pods that have labels matching the labels of the pod template of the replication controller. - - observedGeneration::Int64 : ObservedGeneration reflects the generation of the most recently observed replication controller. - - readyReplicas::Int64 : The number of ready replicas for this replication controller. - - replicas::Int64 : Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ReplicationControllerStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ReplicationControllerCondition} } - fullyLabeledReplicas::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1ReplicationControllerStatus(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("fullyLabeledReplicas"), fullyLabeledReplicas) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiCoreV1ReplicationControllerStatus, Symbol("replicas"), replicas) - return new(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - end -end # type IoK8sApiCoreV1ReplicationControllerStatus - -const _property_types_IoK8sApiCoreV1ReplicationControllerStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiCoreV1ReplicationControllerCondition}", Symbol("fullyLabeledReplicas")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ReplicationControllerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ReplicationControllerStatus[name]))} - -function check_required(o::IoK8sApiCoreV1ReplicationControllerStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ReplicationControllerStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerStatus", :format, val, "int32") - end - if name === Symbol("fullyLabeledReplicas") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ReplicationControllerStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceFieldSelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceFieldSelector.jl deleted file mode 100644 index 6d2c3c81..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceFieldSelector.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceFieldSelector -ResourceFieldSelector represents container resources (cpu, memory) and their output format - - IoK8sApiCoreV1ResourceFieldSelector(; - containerName=nothing, - divisor=nothing, - resource=nothing, - ) - - - containerName::String : Container name: required for volumes, optional for env vars - - divisor::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - resource::String : Required: resource to select -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceFieldSelector <: OpenAPI.APIModel - containerName::Union{Nothing, String} = nothing - divisor::Union{Nothing, String} = nothing - resource::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ResourceFieldSelector(containerName, divisor, resource, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceFieldSelector, Symbol("containerName"), containerName) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceFieldSelector, Symbol("divisor"), divisor) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceFieldSelector, Symbol("resource"), resource) - return new(containerName, divisor, resource, ) - end -end # type IoK8sApiCoreV1ResourceFieldSelector - -const _property_types_IoK8sApiCoreV1ResourceFieldSelector = Dict{Symbol,String}(Symbol("containerName")=>"String", Symbol("divisor")=>"String", Symbol("resource")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceFieldSelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceFieldSelector[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceFieldSelector) - o.resource === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceFieldSelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuota.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuota.jl deleted file mode 100644 index b27b7269..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuota.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceQuota -ResourceQuota sets aggregate quota restrictions enforced per namespace - - IoK8sApiCoreV1ResourceQuota(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1ResourceQuotaSpec - - status::IoK8sApiCoreV1ResourceQuotaStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceQuota <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceQuotaSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ResourceQuotaStatus } - - function IoK8sApiCoreV1ResourceQuota(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuota, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuota, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuota, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuota, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuota, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1ResourceQuota - -const _property_types_IoK8sApiCoreV1ResourceQuota = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1ResourceQuotaSpec", Symbol("status")=>"IoK8sApiCoreV1ResourceQuotaStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceQuota }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceQuota[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceQuota) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceQuota }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaList.jl deleted file mode 100644 index 21ef5ae7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceQuotaList -ResourceQuotaList is a list of ResourceQuota items. - - IoK8sApiCoreV1ResourceQuotaList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1ResourceQuota} : Items is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceQuotaList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ResourceQuota} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ResourceQuotaList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ResourceQuotaList - -const _property_types_IoK8sApiCoreV1ResourceQuotaList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1ResourceQuota}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceQuotaList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceQuotaList[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceQuotaList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceQuotaList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaSpec.jl deleted file mode 100644 index 17c57f5d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaSpec.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceQuotaSpec -ResourceQuotaSpec defines the desired hard limits to enforce for Quota. - - IoK8sApiCoreV1ResourceQuotaSpec(; - hard=nothing, - scopeSelector=nothing, - scopes=nothing, - ) - - - hard::Dict{String, String} : hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ - - scopeSelector::IoK8sApiCoreV1ScopeSelector - - scopes::Vector{String} : A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceQuotaSpec <: OpenAPI.APIModel - hard::Union{Nothing, Dict{String, String}} = nothing - scopeSelector = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ScopeSelector } - scopes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1ResourceQuotaSpec(hard, scopeSelector, scopes, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaSpec, Symbol("hard"), hard) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaSpec, Symbol("scopeSelector"), scopeSelector) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaSpec, Symbol("scopes"), scopes) - return new(hard, scopeSelector, scopes, ) - end -end # type IoK8sApiCoreV1ResourceQuotaSpec - -const _property_types_IoK8sApiCoreV1ResourceQuotaSpec = Dict{Symbol,String}(Symbol("hard")=>"Dict{String, String}", Symbol("scopeSelector")=>"IoK8sApiCoreV1ScopeSelector", Symbol("scopes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceQuotaSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceQuotaSpec[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceQuotaSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceQuotaSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaStatus.jl deleted file mode 100644 index 9a142cc2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceQuotaStatus.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceQuotaStatus -ResourceQuotaStatus defines the enforced hard limits and observed use. - - IoK8sApiCoreV1ResourceQuotaStatus(; - hard=nothing, - used=nothing, - ) - - - hard::Dict{String, String} : Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ - - used::Dict{String, String} : Used is the current observed total usage of the resource in the namespace. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceQuotaStatus <: OpenAPI.APIModel - hard::Union{Nothing, Dict{String, String}} = nothing - used::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiCoreV1ResourceQuotaStatus(hard, used, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaStatus, Symbol("hard"), hard) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceQuotaStatus, Symbol("used"), used) - return new(hard, used, ) - end -end # type IoK8sApiCoreV1ResourceQuotaStatus - -const _property_types_IoK8sApiCoreV1ResourceQuotaStatus = Dict{Symbol,String}(Symbol("hard")=>"Dict{String, String}", Symbol("used")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceQuotaStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceQuotaStatus[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceQuotaStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceQuotaStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceRequirements.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceRequirements.jl deleted file mode 100644 index 7b06dfd1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ResourceRequirements.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ResourceRequirements -ResourceRequirements describes the compute resource requirements. - - IoK8sApiCoreV1ResourceRequirements(; - limits=nothing, - requests=nothing, - ) - - - limits::Dict{String, String} : Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/ - - requests::Dict{String, String} : 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/ -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ResourceRequirements <: OpenAPI.APIModel - limits::Union{Nothing, Dict{String, String}} = nothing - requests::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiCoreV1ResourceRequirements(limits, requests, ) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceRequirements, Symbol("limits"), limits) - OpenAPI.validate_property(IoK8sApiCoreV1ResourceRequirements, Symbol("requests"), requests) - return new(limits, requests, ) - end -end # type IoK8sApiCoreV1ResourceRequirements - -const _property_types_IoK8sApiCoreV1ResourceRequirements = Dict{Symbol,String}(Symbol("limits")=>"Dict{String, String}", Symbol("requests")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ResourceRequirements }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ResourceRequirements[name]))} - -function check_required(o::IoK8sApiCoreV1ResourceRequirements) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ResourceRequirements }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SELinuxOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SELinuxOptions.jl deleted file mode 100644 index bf4003f1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SELinuxOptions.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SELinuxOptions -SELinuxOptions are the labels to be applied to the container - - IoK8sApiCoreV1SELinuxOptions(; - level=nothing, - role=nothing, - type=nothing, - user=nothing, - ) - - - level::String : Level is SELinux level label that applies to the container. - - role::String : Role is a SELinux role label that applies to the container. - - type::String : Type is a SELinux type label that applies to the container. - - user::String : User is a SELinux user label that applies to the container. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SELinuxOptions <: OpenAPI.APIModel - level::Union{Nothing, String} = nothing - role::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - user::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1SELinuxOptions(level, role, type, user, ) - OpenAPI.validate_property(IoK8sApiCoreV1SELinuxOptions, Symbol("level"), level) - OpenAPI.validate_property(IoK8sApiCoreV1SELinuxOptions, Symbol("role"), role) - OpenAPI.validate_property(IoK8sApiCoreV1SELinuxOptions, Symbol("type"), type) - OpenAPI.validate_property(IoK8sApiCoreV1SELinuxOptions, Symbol("user"), user) - return new(level, role, type, user, ) - end -end # type IoK8sApiCoreV1SELinuxOptions - -const _property_types_IoK8sApiCoreV1SELinuxOptions = Dict{Symbol,String}(Symbol("level")=>"String", Symbol("role")=>"String", Symbol("type")=>"String", Symbol("user")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SELinuxOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SELinuxOptions[name]))} - -function check_required(o::IoK8sApiCoreV1SELinuxOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SELinuxOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOPersistentVolumeSource.jl deleted file mode 100644 index 20a2d177..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOPersistentVolumeSource.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ScaleIOPersistentVolumeSource -ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume - - IoK8sApiCoreV1ScaleIOPersistentVolumeSource(; - fsType=nothing, - gateway=nothing, - protectionDomain=nothing, - readOnly=nothing, - secretRef=nothing, - sslEnabled=nothing, - storageMode=nothing, - storagePool=nothing, - system=nothing, - volumeName=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\" - - gateway::String : The host address of the ScaleIO API Gateway. - - protectionDomain::String : The name of the ScaleIO Protection Domain for the configured storage. - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1SecretReference - - sslEnabled::Bool : Flag to enable/disable SSL communication with Gateway, default false - - storageMode::String : Indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned. - - storagePool::String : The ScaleIO Storage Pool associated with the protection domain. - - system::String : The name of the storage system as configured in ScaleIO. - - volumeName::String : The name of a volume already created in the ScaleIO system that is associated with this volume source. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ScaleIOPersistentVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - gateway::Union{Nothing, String} = nothing - protectionDomain::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretReference } - sslEnabled::Union{Nothing, Bool} = nothing - storageMode::Union{Nothing, String} = nothing - storagePool::Union{Nothing, String} = nothing - system::Union{Nothing, String} = nothing - volumeName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ScaleIOPersistentVolumeSource(fsType, gateway, protectionDomain, readOnly, secretRef, sslEnabled, storageMode, storagePool, system, volumeName, ) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("gateway"), gateway) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("protectionDomain"), protectionDomain) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("sslEnabled"), sslEnabled) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("storageMode"), storageMode) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("storagePool"), storagePool) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("system"), system) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, Symbol("volumeName"), volumeName) - return new(fsType, gateway, protectionDomain, readOnly, secretRef, sslEnabled, storageMode, storagePool, system, volumeName, ) - end -end # type IoK8sApiCoreV1ScaleIOPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1ScaleIOPersistentVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("gateway")=>"String", Symbol("protectionDomain")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1SecretReference", Symbol("sslEnabled")=>"Bool", Symbol("storageMode")=>"String", Symbol("storagePool")=>"String", Symbol("system")=>"String", Symbol("volumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ScaleIOPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ScaleIOPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ScaleIOPersistentVolumeSource) - o.gateway === nothing && (return false) - o.secretRef === nothing && (return false) - o.system === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ScaleIOPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOVolumeSource.jl deleted file mode 100644 index fed50017..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScaleIOVolumeSource.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ScaleIOVolumeSource -ScaleIOVolumeSource represents a persistent ScaleIO volume - - IoK8sApiCoreV1ScaleIOVolumeSource(; - fsType=nothing, - gateway=nothing, - protectionDomain=nothing, - readOnly=nothing, - secretRef=nothing, - sslEnabled=nothing, - storageMode=nothing, - storagePool=nothing, - system=nothing, - volumeName=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\". - - gateway::String : The host address of the ScaleIO API Gateway. - - protectionDomain::String : The name of the ScaleIO Protection Domain for the configured storage. - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1LocalObjectReference - - sslEnabled::Bool : Flag to enable/disable SSL communication with Gateway, default false - - storageMode::String : Indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned. - - storagePool::String : The ScaleIO Storage Pool associated with the protection domain. - - system::String : The name of the storage system as configured in ScaleIO. - - volumeName::String : The name of a volume already created in the ScaleIO system that is associated with this volume source. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ScaleIOVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - gateway::Union{Nothing, String} = nothing - protectionDomain::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - sslEnabled::Union{Nothing, Bool} = nothing - storageMode::Union{Nothing, String} = nothing - storagePool::Union{Nothing, String} = nothing - system::Union{Nothing, String} = nothing - volumeName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ScaleIOVolumeSource(fsType, gateway, protectionDomain, readOnly, secretRef, sslEnabled, storageMode, storagePool, system, volumeName, ) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("gateway"), gateway) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("protectionDomain"), protectionDomain) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("sslEnabled"), sslEnabled) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("storageMode"), storageMode) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("storagePool"), storagePool) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("system"), system) - OpenAPI.validate_property(IoK8sApiCoreV1ScaleIOVolumeSource, Symbol("volumeName"), volumeName) - return new(fsType, gateway, protectionDomain, readOnly, secretRef, sslEnabled, storageMode, storagePool, system, volumeName, ) - end -end # type IoK8sApiCoreV1ScaleIOVolumeSource - -const _property_types_IoK8sApiCoreV1ScaleIOVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("gateway")=>"String", Symbol("protectionDomain")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("sslEnabled")=>"Bool", Symbol("storageMode")=>"String", Symbol("storagePool")=>"String", Symbol("system")=>"String", Symbol("volumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ScaleIOVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ScaleIOVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1ScaleIOVolumeSource) - o.gateway === nothing && (return false) - o.secretRef === nothing && (return false) - o.system === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ScaleIOVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopeSelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopeSelector.jl deleted file mode 100644 index 1f321e86..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopeSelector.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ScopeSelector -A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements. - - IoK8sApiCoreV1ScopeSelector(; - matchExpressions=nothing, - ) - - - matchExpressions::Vector{IoK8sApiCoreV1ScopedResourceSelectorRequirement} : A list of scope selector requirements by scope of the resources. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ScopeSelector <: OpenAPI.APIModel - matchExpressions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ScopedResourceSelectorRequirement} } - - function IoK8sApiCoreV1ScopeSelector(matchExpressions, ) - OpenAPI.validate_property(IoK8sApiCoreV1ScopeSelector, Symbol("matchExpressions"), matchExpressions) - return new(matchExpressions, ) - end -end # type IoK8sApiCoreV1ScopeSelector - -const _property_types_IoK8sApiCoreV1ScopeSelector = Dict{Symbol,String}(Symbol("matchExpressions")=>"Vector{IoK8sApiCoreV1ScopedResourceSelectorRequirement}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ScopeSelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ScopeSelector[name]))} - -function check_required(o::IoK8sApiCoreV1ScopeSelector) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ScopeSelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopedResourceSelectorRequirement.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopedResourceSelectorRequirement.jl deleted file mode 100644 index 8b9e4213..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ScopedResourceSelectorRequirement.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ScopedResourceSelectorRequirement -A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values. - - IoK8sApiCoreV1ScopedResourceSelectorRequirement(; - operator=nothing, - scopeName=nothing, - values=nothing, - ) - - - operator::String : Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. - - scopeName::String : The name of the scope that the selector applies to. - - values::Vector{String} : An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ScopedResourceSelectorRequirement <: OpenAPI.APIModel - operator::Union{Nothing, String} = nothing - scopeName::Union{Nothing, String} = nothing - values::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1ScopedResourceSelectorRequirement(operator, scopeName, values, ) - OpenAPI.validate_property(IoK8sApiCoreV1ScopedResourceSelectorRequirement, Symbol("operator"), operator) - OpenAPI.validate_property(IoK8sApiCoreV1ScopedResourceSelectorRequirement, Symbol("scopeName"), scopeName) - OpenAPI.validate_property(IoK8sApiCoreV1ScopedResourceSelectorRequirement, Symbol("values"), values) - return new(operator, scopeName, values, ) - end -end # type IoK8sApiCoreV1ScopedResourceSelectorRequirement - -const _property_types_IoK8sApiCoreV1ScopedResourceSelectorRequirement = Dict{Symbol,String}(Symbol("operator")=>"String", Symbol("scopeName")=>"String", Symbol("values")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ScopedResourceSelectorRequirement }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ScopedResourceSelectorRequirement[name]))} - -function check_required(o::IoK8sApiCoreV1ScopedResourceSelectorRequirement) - o.operator === nothing && (return false) - o.scopeName === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ScopedResourceSelectorRequirement }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Secret.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Secret.jl deleted file mode 100644 index 130c9702..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Secret.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Secret -Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. - - IoK8sApiCoreV1Secret(; - apiVersion=nothing, - data=nothing, - kind=nothing, - metadata=nothing, - stringData=nothing, - type=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - data::Dict{String, Vector{UInt8}} : Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4 - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - stringData::Dict{String, String} : stringData allows specifying non-binary secret data in string form. It is provided as a write-only convenience method. All keys and values are merged into the data field on write, overwriting any existing values. It is never output when reading from the API. - - type::String : Used to facilitate programmatic handling of secret data. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Secret <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - data::Union{Nothing, Dict{String, Vector{UInt8}}} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - stringData::Union{Nothing, Dict{String, String}} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Secret(apiVersion, data, kind, metadata, stringData, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("data"), data) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("stringData"), stringData) - OpenAPI.validate_property(IoK8sApiCoreV1Secret, Symbol("type"), type) - return new(apiVersion, data, kind, metadata, stringData, type, ) - end -end # type IoK8sApiCoreV1Secret - -const _property_types_IoK8sApiCoreV1Secret = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("data")=>"Dict{String, Vector{UInt8}}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("stringData")=>"Dict{String, String}", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Secret }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Secret[name]))} - -function check_required(o::IoK8sApiCoreV1Secret) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Secret }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretEnvSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretEnvSource.jl deleted file mode 100644 index 833f8607..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretEnvSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretEnvSource -SecretEnvSource selects a Secret to populate the environment variables with. The contents of the target Secret's Data field will represent the key-value pairs as environment variables. - - IoK8sApiCoreV1SecretEnvSource(; - name=nothing, - optional=nothing, - ) - - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the Secret must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretEnvSource <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1SecretEnvSource(name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretEnvSource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1SecretEnvSource, Symbol("optional"), optional) - return new(name, optional, ) - end -end # type IoK8sApiCoreV1SecretEnvSource - -const _property_types_IoK8sApiCoreV1SecretEnvSource = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretEnvSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretEnvSource[name]))} - -function check_required(o::IoK8sApiCoreV1SecretEnvSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretEnvSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretKeySelector.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretKeySelector.jl deleted file mode 100644 index 300cc0e1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretKeySelector.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretKeySelector -SecretKeySelector selects a key of a Secret. - - IoK8sApiCoreV1SecretKeySelector(; - key=nothing, - name=nothing, - optional=nothing, - ) - - - key::String : The key of the secret to select from. Must be a valid secret key. - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the Secret or its key must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretKeySelector <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1SecretKeySelector(key, name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretKeySelector, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1SecretKeySelector, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1SecretKeySelector, Symbol("optional"), optional) - return new(key, name, optional, ) - end -end # type IoK8sApiCoreV1SecretKeySelector - -const _property_types_IoK8sApiCoreV1SecretKeySelector = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretKeySelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretKeySelector[name]))} - -function check_required(o::IoK8sApiCoreV1SecretKeySelector) - o.key === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretKeySelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretList.jl deleted file mode 100644 index f68c8b8d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretList -SecretList is a list of Secret. - - IoK8sApiCoreV1SecretList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Secret} : Items is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Secret} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1SecretList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1SecretList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1SecretList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1SecretList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1SecretList - -const _property_types_IoK8sApiCoreV1SecretList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Secret}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretList[name]))} - -function check_required(o::IoK8sApiCoreV1SecretList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretProjection.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretProjection.jl deleted file mode 100644 index 98472657..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretProjection.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretProjection -Adapts a secret into a projected volume. The contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode. - - IoK8sApiCoreV1SecretProjection(; - items=nothing, - name=nothing, - optional=nothing, - ) - - - items::Vector{IoK8sApiCoreV1KeyToPath} : If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. - - name::String : Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - optional::Bool : Specify whether the Secret or its key must be defined -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretProjection <: OpenAPI.APIModel - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1KeyToPath} } - name::Union{Nothing, String} = nothing - optional::Union{Nothing, Bool} = nothing - - function IoK8sApiCoreV1SecretProjection(items, name, optional, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretProjection, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1SecretProjection, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1SecretProjection, Symbol("optional"), optional) - return new(items, name, optional, ) - end -end # type IoK8sApiCoreV1SecretProjection - -const _property_types_IoK8sApiCoreV1SecretProjection = Dict{Symbol,String}(Symbol("items")=>"Vector{IoK8sApiCoreV1KeyToPath}", Symbol("name")=>"String", Symbol("optional")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretProjection }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretProjection[name]))} - -function check_required(o::IoK8sApiCoreV1SecretProjection) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretProjection }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretReference.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretReference.jl deleted file mode 100644 index 905cc31f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretReference.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretReference -SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace - - IoK8sApiCoreV1SecretReference(; - name=nothing, - namespace=nothing, - ) - - - name::String : Name is unique within a namespace to reference a secret resource. - - namespace::String : Namespace defines the space within which the secret name must be unique. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1SecretReference(name, namespace, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1SecretReference, Symbol("namespace"), namespace) - return new(name, namespace, ) - end -end # type IoK8sApiCoreV1SecretReference - -const _property_types_IoK8sApiCoreV1SecretReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretReference[name]))} - -function check_required(o::IoK8sApiCoreV1SecretReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretVolumeSource.jl deleted file mode 100644 index 95555f9c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecretVolumeSource.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecretVolumeSource -Adapts a Secret into a volume. The contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling. - - IoK8sApiCoreV1SecretVolumeSource(; - defaultMode=nothing, - items=nothing, - optional=nothing, - secretName=nothing, - ) - - - defaultMode::Int64 : Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. - - items::Vector{IoK8sApiCoreV1KeyToPath} : If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. - - optional::Bool : Specify whether the Secret or its keys must be defined - - secretName::String : Name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecretVolumeSource <: OpenAPI.APIModel - defaultMode::Union{Nothing, Int64} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1KeyToPath} } - optional::Union{Nothing, Bool} = nothing - secretName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1SecretVolumeSource(defaultMode, items, optional, secretName, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecretVolumeSource, Symbol("defaultMode"), defaultMode) - OpenAPI.validate_property(IoK8sApiCoreV1SecretVolumeSource, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1SecretVolumeSource, Symbol("optional"), optional) - OpenAPI.validate_property(IoK8sApiCoreV1SecretVolumeSource, Symbol("secretName"), secretName) - return new(defaultMode, items, optional, secretName, ) - end -end # type IoK8sApiCoreV1SecretVolumeSource - -const _property_types_IoK8sApiCoreV1SecretVolumeSource = Dict{Symbol,String}(Symbol("defaultMode")=>"Int64", Symbol("items")=>"Vector{IoK8sApiCoreV1KeyToPath}", Symbol("optional")=>"Bool", Symbol("secretName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecretVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecretVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1SecretVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecretVolumeSource }, name::Symbol, val) - if name === Symbol("defaultMode") - OpenAPI.validate_param(name, "IoK8sApiCoreV1SecretVolumeSource", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecurityContext.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecurityContext.jl deleted file mode 100644 index d557dc7d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SecurityContext.jl +++ /dev/null @@ -1,73 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SecurityContext -SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence. - - IoK8sApiCoreV1SecurityContext(; - allowPrivilegeEscalation=nothing, - capabilities=nothing, - privileged=nothing, - procMount=nothing, - readOnlyRootFilesystem=nothing, - runAsGroup=nothing, - runAsNonRoot=nothing, - runAsUser=nothing, - seLinuxOptions=nothing, - windowsOptions=nothing, - ) - - - allowPrivilegeEscalation::Bool : AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN - - capabilities::IoK8sApiCoreV1Capabilities - - privileged::Bool : Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. - - procMount::String : procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. - - readOnlyRootFilesystem::Bool : Whether this container has a read-only root filesystem. Default is false. - - runAsGroup::Int64 : The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. - - runAsNonRoot::Bool : Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. - - runAsUser::Int64 : The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. - - seLinuxOptions::IoK8sApiCoreV1SELinuxOptions - - windowsOptions::IoK8sApiCoreV1WindowsSecurityContextOptions -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SecurityContext <: OpenAPI.APIModel - allowPrivilegeEscalation::Union{Nothing, Bool} = nothing - capabilities = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1Capabilities } - privileged::Union{Nothing, Bool} = nothing - procMount::Union{Nothing, String} = nothing - readOnlyRootFilesystem::Union{Nothing, Bool} = nothing - runAsGroup::Union{Nothing, Int64} = nothing - runAsNonRoot::Union{Nothing, Bool} = nothing - runAsUser::Union{Nothing, Int64} = nothing - seLinuxOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SELinuxOptions } - windowsOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1WindowsSecurityContextOptions } - - function IoK8sApiCoreV1SecurityContext(allowPrivilegeEscalation, capabilities, privileged, procMount, readOnlyRootFilesystem, runAsGroup, runAsNonRoot, runAsUser, seLinuxOptions, windowsOptions, ) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("allowPrivilegeEscalation"), allowPrivilegeEscalation) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("capabilities"), capabilities) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("privileged"), privileged) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("procMount"), procMount) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("readOnlyRootFilesystem"), readOnlyRootFilesystem) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("runAsGroup"), runAsGroup) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("runAsNonRoot"), runAsNonRoot) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("runAsUser"), runAsUser) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("seLinuxOptions"), seLinuxOptions) - OpenAPI.validate_property(IoK8sApiCoreV1SecurityContext, Symbol("windowsOptions"), windowsOptions) - return new(allowPrivilegeEscalation, capabilities, privileged, procMount, readOnlyRootFilesystem, runAsGroup, runAsNonRoot, runAsUser, seLinuxOptions, windowsOptions, ) - end -end # type IoK8sApiCoreV1SecurityContext - -const _property_types_IoK8sApiCoreV1SecurityContext = Dict{Symbol,String}(Symbol("allowPrivilegeEscalation")=>"Bool", Symbol("capabilities")=>"IoK8sApiCoreV1Capabilities", Symbol("privileged")=>"Bool", Symbol("procMount")=>"String", Symbol("readOnlyRootFilesystem")=>"Bool", Symbol("runAsGroup")=>"Int64", Symbol("runAsNonRoot")=>"Bool", Symbol("runAsUser")=>"Int64", Symbol("seLinuxOptions")=>"IoK8sApiCoreV1SELinuxOptions", Symbol("windowsOptions")=>"IoK8sApiCoreV1WindowsSecurityContextOptions", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SecurityContext }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SecurityContext[name]))} - -function check_required(o::IoK8sApiCoreV1SecurityContext) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SecurityContext }, name::Symbol, val) - if name === Symbol("runAsGroup") - OpenAPI.validate_param(name, "IoK8sApiCoreV1SecurityContext", :format, val, "int64") - end - if name === Symbol("runAsUser") - OpenAPI.validate_param(name, "IoK8sApiCoreV1SecurityContext", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Service.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Service.jl deleted file mode 100644 index e83fa211..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Service.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Service -Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. - - IoK8sApiCoreV1Service(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiCoreV1ServiceSpec - - status::IoK8sApiCoreV1ServiceStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Service <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ServiceSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ServiceStatus } - - function IoK8sApiCoreV1Service(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiCoreV1Service, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1Service, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1Service, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1Service, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiCoreV1Service, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiCoreV1Service - -const _property_types_IoK8sApiCoreV1Service = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiCoreV1ServiceSpec", Symbol("status")=>"IoK8sApiCoreV1ServiceStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Service }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Service[name]))} - -function check_required(o::IoK8sApiCoreV1Service) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Service }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccount.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccount.jl deleted file mode 100644 index f7afcd51..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccount.jl +++ /dev/null @@ -1,51 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceAccount -ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets - - IoK8sApiCoreV1ServiceAccount(; - apiVersion=nothing, - automountServiceAccountToken=nothing, - imagePullSecrets=nothing, - kind=nothing, - metadata=nothing, - secrets=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - automountServiceAccountToken::Bool : AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level. - - imagePullSecrets::Vector{IoK8sApiCoreV1LocalObjectReference} : ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - secrets::Vector{IoK8sApiCoreV1ObjectReference} : Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount. More info: https://kubernetes.io/docs/concepts/configuration/secret -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceAccount <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - automountServiceAccountToken::Union{Nothing, Bool} = nothing - imagePullSecrets::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1LocalObjectReference} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - secrets::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ObjectReference} } - - function IoK8sApiCoreV1ServiceAccount(apiVersion, automountServiceAccountToken, imagePullSecrets, kind, metadata, secrets, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("automountServiceAccountToken"), automountServiceAccountToken) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("imagePullSecrets"), imagePullSecrets) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccount, Symbol("secrets"), secrets) - return new(apiVersion, automountServiceAccountToken, imagePullSecrets, kind, metadata, secrets, ) - end -end # type IoK8sApiCoreV1ServiceAccount - -const _property_types_IoK8sApiCoreV1ServiceAccount = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("automountServiceAccountToken")=>"Bool", Symbol("imagePullSecrets")=>"Vector{IoK8sApiCoreV1LocalObjectReference}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("secrets")=>"Vector{IoK8sApiCoreV1ObjectReference}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceAccount }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceAccount[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceAccount) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceAccount }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountList.jl deleted file mode 100644 index c102945f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceAccountList -ServiceAccountList is a list of ServiceAccount objects - - IoK8sApiCoreV1ServiceAccountList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1ServiceAccount} : List of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceAccountList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ServiceAccount} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ServiceAccountList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ServiceAccountList - -const _property_types_IoK8sApiCoreV1ServiceAccountList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1ServiceAccount}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceAccountList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceAccountList[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceAccountList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceAccountList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountTokenProjection.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountTokenProjection.jl deleted file mode 100644 index 6a28704b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceAccountTokenProjection.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceAccountTokenProjection -ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise). - - IoK8sApiCoreV1ServiceAccountTokenProjection(; - audience=nothing, - expirationSeconds=nothing, - path=nothing, - ) - - - audience::String : Audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. - - expirationSeconds::Int64 : ExpirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes. - - path::String : Path is the path relative to the mount point of the file to project the token into. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceAccountTokenProjection <: OpenAPI.APIModel - audience::Union{Nothing, String} = nothing - expirationSeconds::Union{Nothing, Int64} = nothing - path::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ServiceAccountTokenProjection(audience, expirationSeconds, path, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountTokenProjection, Symbol("audience"), audience) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountTokenProjection, Symbol("expirationSeconds"), expirationSeconds) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceAccountTokenProjection, Symbol("path"), path) - return new(audience, expirationSeconds, path, ) - end -end # type IoK8sApiCoreV1ServiceAccountTokenProjection - -const _property_types_IoK8sApiCoreV1ServiceAccountTokenProjection = Dict{Symbol,String}(Symbol("audience")=>"String", Symbol("expirationSeconds")=>"Int64", Symbol("path")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceAccountTokenProjection }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceAccountTokenProjection[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceAccountTokenProjection) - o.path === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceAccountTokenProjection }, name::Symbol, val) - if name === Symbol("expirationSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ServiceAccountTokenProjection", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceList.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceList.jl deleted file mode 100644 index 5136d577..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceList -ServiceList holds a list of services. - - IoK8sApiCoreV1ServiceList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCoreV1Service} : List of services - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Service} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCoreV1ServiceList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCoreV1ServiceList - -const _property_types_IoK8sApiCoreV1ServiceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCoreV1Service}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceList[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServicePort.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServicePort.jl deleted file mode 100644 index 85910a83..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServicePort.jl +++ /dev/null @@ -1,57 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServicePort -ServicePort contains information on service's port. - - IoK8sApiCoreV1ServicePort(; - name=nothing, - nodePort=nothing, - port=nothing, - protocol=nothing, - targetPort=nothing, - ) - - - name::String : The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. When considering the endpoints for a Service, this must match the 'name' field in the EndpointPort. Optional if only one ServicePort is defined on this service. - - nodePort::Int64 : The port on each node on which this service is exposed when type=NodePort or LoadBalancer. Usually assigned by the system. If specified, it will be allocated to the service if unused or else creation of the service will fail. Default is to auto-allocate a port if the ServiceType of this Service requires one. More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport - - port::Int64 : The port that will be exposed by this service. - - protocol::String : The IP protocol for this port. Supports \"TCP\", \"UDP\", and \"SCTP\". Default is TCP. - - targetPort::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServicePort <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - nodePort::Union{Nothing, Int64} = nothing - port::Union{Nothing, Int64} = nothing - protocol::Union{Nothing, String} = nothing - targetPort::Union{Nothing, Any} = nothing - - function IoK8sApiCoreV1ServicePort(name, nodePort, port, protocol, targetPort, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServicePort, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1ServicePort, Symbol("nodePort"), nodePort) - OpenAPI.validate_property(IoK8sApiCoreV1ServicePort, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiCoreV1ServicePort, Symbol("protocol"), protocol) - OpenAPI.validate_property(IoK8sApiCoreV1ServicePort, Symbol("targetPort"), targetPort) - return new(name, nodePort, port, protocol, targetPort, ) - end -end # type IoK8sApiCoreV1ServicePort - -const _property_types_IoK8sApiCoreV1ServicePort = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("nodePort")=>"Int64", Symbol("port")=>"Int64", Symbol("protocol")=>"String", Symbol("targetPort")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServicePort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServicePort[name]))} - -function check_required(o::IoK8sApiCoreV1ServicePort) - o.port === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServicePort }, name::Symbol, val) - if name === Symbol("nodePort") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ServicePort", :format, val, "int32") - end - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ServicePort", :format, val, "int32") - end - if name === Symbol("targetPort") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ServicePort", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceSpec.jl deleted file mode 100644 index 3dc2dc9d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceSpec.jl +++ /dev/null @@ -1,90 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceSpec -ServiceSpec describes the attributes that a user creates on a service. - - IoK8sApiCoreV1ServiceSpec(; - clusterIP=nothing, - externalIPs=nothing, - externalName=nothing, - externalTrafficPolicy=nothing, - healthCheckNodePort=nothing, - ipFamily=nothing, - loadBalancerIP=nothing, - loadBalancerSourceRanges=nothing, - ports=nothing, - publishNotReadyAddresses=nothing, - selector=nothing, - sessionAffinity=nothing, - sessionAffinityConfig=nothing, - topologyKeys=nothing, - type=nothing, - ) - - - clusterIP::String : clusterIP is the IP address of the service and is usually assigned randomly by the master. If an address is specified manually and is not in use by others, it will be allocated to the service; otherwise, creation of the service will fail. This field can not be changed through updates. Valid values are \"None\", empty string (\"\"), or a valid IP address. \"None\" can be specified for headless services when proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies - - externalIPs::Vector{String} : externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system. - - externalName::String : externalName is the external reference that kubedns or equivalent will return as a CNAME record for this service. No proxying will be involved. Must be a valid RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires Type to be ExternalName. - - externalTrafficPolicy::String : externalTrafficPolicy denotes if this Service desires to route external traffic to node-local or cluster-wide endpoints. \"Local\" preserves the client source IP and avoids a second hop for LoadBalancer and Nodeport type services, but risks potentially imbalanced traffic spreading. \"Cluster\" obscures the client source IP and may cause a second hop to another node, but should have good overall load-spreading. - - healthCheckNodePort::Int64 : healthCheckNodePort specifies the healthcheck nodePort for the service. If not specified, HealthCheckNodePort is created by the service api backend with the allocated nodePort. Will use user-specified nodePort value if specified by the client. Only effects when Type is set to LoadBalancer and ExternalTrafficPolicy is set to Local. - - ipFamily::String : ipFamily specifies whether this Service has a preference for a particular IP family (e.g. IPv4 vs. IPv6). If a specific IP family is requested, the clusterIP field will be allocated from that family, if it is available in the cluster. If no IP family is requested, the cluster's primary IP family will be used. Other IP fields (loadBalancerIP, loadBalancerSourceRanges, externalIPs) and controllers which allocate external load-balancers should use the same IP family. Endpoints for this Service will be of this family. This field is immutable after creation. Assigning a ServiceIPFamily not available in the cluster (e.g. IPv6 in IPv4 only cluster) is an error condition and will fail during clusterIP assignment. - - loadBalancerIP::String : Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. - - loadBalancerSourceRanges::Vector{String} : If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/ - - ports::Vector{IoK8sApiCoreV1ServicePort} : The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies - - publishNotReadyAddresses::Bool : publishNotReadyAddresses, when set to true, indicates that DNS implementations must publish the notReadyAddresses of subsets for the Endpoints associated with the Service. The default value is false. The primary use case for setting this field is to use a StatefulSet's Headless Service to propagate SRV records for its Pods without respect to their readiness for purpose of peer discovery. - - selector::Dict{String, String} : Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/ - - sessionAffinity::String : Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies - - sessionAffinityConfig::IoK8sApiCoreV1SessionAffinityConfig - - topologyKeys::Vector{String} : topologyKeys is a preference-order list of topology keys which implementations of services should use to preferentially sort endpoints when accessing this Service, it can not be used at the same time as externalTrafficPolicy=Local. Topology keys must be valid label keys and at most 16 keys may be specified. Endpoints are chosen based on the first topology key with available backends. If this field is specified and all entries have no backends that match the topology of the client, the service has no backends for that client and connections should fail. The special value \"*\" may be used to mean \"any topology\". This catch-all value, if used, only makes sense as the last value in the list. If this is not specified or empty, no topology constraints will be applied. - - type::String : type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ExternalName\" maps to the specified externalName. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a stable IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the clusterIP. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceSpec <: OpenAPI.APIModel - clusterIP::Union{Nothing, String} = nothing - externalIPs::Union{Nothing, Vector{String}} = nothing - externalName::Union{Nothing, String} = nothing - externalTrafficPolicy::Union{Nothing, String} = nothing - healthCheckNodePort::Union{Nothing, Int64} = nothing - ipFamily::Union{Nothing, String} = nothing - loadBalancerIP::Union{Nothing, String} = nothing - loadBalancerSourceRanges::Union{Nothing, Vector{String}} = nothing - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1ServicePort} } - publishNotReadyAddresses::Union{Nothing, Bool} = nothing - selector::Union{Nothing, Dict{String, String}} = nothing - sessionAffinity::Union{Nothing, String} = nothing - sessionAffinityConfig = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SessionAffinityConfig } - topologyKeys::Union{Nothing, Vector{String}} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1ServiceSpec(clusterIP, externalIPs, externalName, externalTrafficPolicy, healthCheckNodePort, ipFamily, loadBalancerIP, loadBalancerSourceRanges, ports, publishNotReadyAddresses, selector, sessionAffinity, sessionAffinityConfig, topologyKeys, type, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("clusterIP"), clusterIP) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("externalIPs"), externalIPs) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("externalName"), externalName) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("externalTrafficPolicy"), externalTrafficPolicy) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("healthCheckNodePort"), healthCheckNodePort) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("ipFamily"), ipFamily) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("loadBalancerIP"), loadBalancerIP) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("loadBalancerSourceRanges"), loadBalancerSourceRanges) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("ports"), ports) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("publishNotReadyAddresses"), publishNotReadyAddresses) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("sessionAffinity"), sessionAffinity) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("sessionAffinityConfig"), sessionAffinityConfig) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("topologyKeys"), topologyKeys) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceSpec, Symbol("type"), type) - return new(clusterIP, externalIPs, externalName, externalTrafficPolicy, healthCheckNodePort, ipFamily, loadBalancerIP, loadBalancerSourceRanges, ports, publishNotReadyAddresses, selector, sessionAffinity, sessionAffinityConfig, topologyKeys, type, ) - end -end # type IoK8sApiCoreV1ServiceSpec - -const _property_types_IoK8sApiCoreV1ServiceSpec = Dict{Symbol,String}(Symbol("clusterIP")=>"String", Symbol("externalIPs")=>"Vector{String}", Symbol("externalName")=>"String", Symbol("externalTrafficPolicy")=>"String", Symbol("healthCheckNodePort")=>"Int64", Symbol("ipFamily")=>"String", Symbol("loadBalancerIP")=>"String", Symbol("loadBalancerSourceRanges")=>"Vector{String}", Symbol("ports")=>"Vector{IoK8sApiCoreV1ServicePort}", Symbol("publishNotReadyAddresses")=>"Bool", Symbol("selector")=>"Dict{String, String}", Symbol("sessionAffinity")=>"String", Symbol("sessionAffinityConfig")=>"IoK8sApiCoreV1SessionAffinityConfig", Symbol("topologyKeys")=>"Vector{String}", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceSpec[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceSpec }, name::Symbol, val) - if name === Symbol("healthCheckNodePort") - OpenAPI.validate_param(name, "IoK8sApiCoreV1ServiceSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceStatus.jl deleted file mode 100644 index 044354b4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1ServiceStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.ServiceStatus -ServiceStatus represents the current status of a service. - - IoK8sApiCoreV1ServiceStatus(; - loadBalancer=nothing, - ) - - - loadBalancer::IoK8sApiCoreV1LoadBalancerStatus -""" -Base.@kwdef mutable struct IoK8sApiCoreV1ServiceStatus <: OpenAPI.APIModel - loadBalancer = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LoadBalancerStatus } - - function IoK8sApiCoreV1ServiceStatus(loadBalancer, ) - OpenAPI.validate_property(IoK8sApiCoreV1ServiceStatus, Symbol("loadBalancer"), loadBalancer) - return new(loadBalancer, ) - end -end # type IoK8sApiCoreV1ServiceStatus - -const _property_types_IoK8sApiCoreV1ServiceStatus = Dict{Symbol,String}(Symbol("loadBalancer")=>"IoK8sApiCoreV1LoadBalancerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1ServiceStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1ServiceStatus[name]))} - -function check_required(o::IoK8sApiCoreV1ServiceStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1ServiceStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SessionAffinityConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1SessionAffinityConfig.jl deleted file mode 100644 index 76e27b10..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1SessionAffinityConfig.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.SessionAffinityConfig -SessionAffinityConfig represents the configurations of session affinity. - - IoK8sApiCoreV1SessionAffinityConfig(; - clientIP=nothing, - ) - - - clientIP::IoK8sApiCoreV1ClientIPConfig -""" -Base.@kwdef mutable struct IoK8sApiCoreV1SessionAffinityConfig <: OpenAPI.APIModel - clientIP = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ClientIPConfig } - - function IoK8sApiCoreV1SessionAffinityConfig(clientIP, ) - OpenAPI.validate_property(IoK8sApiCoreV1SessionAffinityConfig, Symbol("clientIP"), clientIP) - return new(clientIP, ) - end -end # type IoK8sApiCoreV1SessionAffinityConfig - -const _property_types_IoK8sApiCoreV1SessionAffinityConfig = Dict{Symbol,String}(Symbol("clientIP")=>"IoK8sApiCoreV1ClientIPConfig", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1SessionAffinityConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1SessionAffinityConfig[name]))} - -function check_required(o::IoK8sApiCoreV1SessionAffinityConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1SessionAffinityConfig }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSPersistentVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSPersistentVolumeSource.jl deleted file mode 100644 index e2ecab66..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSPersistentVolumeSource.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.StorageOSPersistentVolumeSource -Represents a StorageOS persistent volume resource. - - IoK8sApiCoreV1StorageOSPersistentVolumeSource(; - fsType=nothing, - readOnly=nothing, - secretRef=nothing, - volumeName=nothing, - volumeNamespace=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1ObjectReference - - volumeName::String : VolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. - - volumeNamespace::String : VolumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1StorageOSPersistentVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - volumeName::Union{Nothing, String} = nothing - volumeNamespace::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1StorageOSPersistentVolumeSource(fsType, readOnly, secretRef, volumeName, volumeNamespace, ) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSPersistentVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSPersistentVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSPersistentVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSPersistentVolumeSource, Symbol("volumeName"), volumeName) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSPersistentVolumeSource, Symbol("volumeNamespace"), volumeNamespace) - return new(fsType, readOnly, secretRef, volumeName, volumeNamespace, ) - end -end # type IoK8sApiCoreV1StorageOSPersistentVolumeSource - -const _property_types_IoK8sApiCoreV1StorageOSPersistentVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1ObjectReference", Symbol("volumeName")=>"String", Symbol("volumeNamespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1StorageOSPersistentVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1StorageOSPersistentVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1StorageOSPersistentVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1StorageOSPersistentVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSVolumeSource.jl deleted file mode 100644 index 0f8f4e68..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1StorageOSVolumeSource.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.StorageOSVolumeSource -Represents a StorageOS persistent volume resource. - - IoK8sApiCoreV1StorageOSVolumeSource(; - fsType=nothing, - readOnly=nothing, - secretRef=nothing, - volumeName=nothing, - volumeNamespace=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - readOnly::Bool : Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. - - secretRef::IoK8sApiCoreV1LocalObjectReference - - volumeName::String : VolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. - - volumeNamespace::String : VolumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1StorageOSVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - secretRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LocalObjectReference } - volumeName::Union{Nothing, String} = nothing - volumeNamespace::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1StorageOSVolumeSource(fsType, readOnly, secretRef, volumeName, volumeNamespace, ) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSVolumeSource, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSVolumeSource, Symbol("secretRef"), secretRef) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSVolumeSource, Symbol("volumeName"), volumeName) - OpenAPI.validate_property(IoK8sApiCoreV1StorageOSVolumeSource, Symbol("volumeNamespace"), volumeNamespace) - return new(fsType, readOnly, secretRef, volumeName, volumeNamespace, ) - end -end # type IoK8sApiCoreV1StorageOSVolumeSource - -const _property_types_IoK8sApiCoreV1StorageOSVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("readOnly")=>"Bool", Symbol("secretRef")=>"IoK8sApiCoreV1LocalObjectReference", Symbol("volumeName")=>"String", Symbol("volumeNamespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1StorageOSVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1StorageOSVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1StorageOSVolumeSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1StorageOSVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Sysctl.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Sysctl.jl deleted file mode 100644 index 66d9db47..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Sysctl.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Sysctl -Sysctl defines a kernel parameter to be set - - IoK8sApiCoreV1Sysctl(; - name=nothing, - value=nothing, - ) - - - name::String : Name of a property to set - - value::String : Value of a property to set -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Sysctl <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Sysctl(name, value, ) - OpenAPI.validate_property(IoK8sApiCoreV1Sysctl, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1Sysctl, Symbol("value"), value) - return new(name, value, ) - end -end # type IoK8sApiCoreV1Sysctl - -const _property_types_IoK8sApiCoreV1Sysctl = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Sysctl }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Sysctl[name]))} - -function check_required(o::IoK8sApiCoreV1Sysctl) - o.name === nothing && (return false) - o.value === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Sysctl }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TCPSocketAction.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1TCPSocketAction.jl deleted file mode 100644 index 974e598e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TCPSocketAction.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.TCPSocketAction -TCPSocketAction describes an action based on opening a socket - - IoK8sApiCoreV1TCPSocketAction(; - host=nothing, - port=nothing, - ) - - - host::String : Optional: Host name to connect to, defaults to the pod IP. - - port::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1TCPSocketAction <: OpenAPI.APIModel - host::Union{Nothing, String} = nothing - port::Union{Nothing, Any} = nothing - - function IoK8sApiCoreV1TCPSocketAction(host, port, ) - OpenAPI.validate_property(IoK8sApiCoreV1TCPSocketAction, Symbol("host"), host) - OpenAPI.validate_property(IoK8sApiCoreV1TCPSocketAction, Symbol("port"), port) - return new(host, port, ) - end -end # type IoK8sApiCoreV1TCPSocketAction - -const _property_types_IoK8sApiCoreV1TCPSocketAction = Dict{Symbol,String}(Symbol("host")=>"String", Symbol("port")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1TCPSocketAction }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1TCPSocketAction[name]))} - -function check_required(o::IoK8sApiCoreV1TCPSocketAction) - o.port === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1TCPSocketAction }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiCoreV1TCPSocketAction", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Taint.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Taint.jl deleted file mode 100644 index 859e0599..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Taint.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Taint -The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint. - - IoK8sApiCoreV1Taint(; - effect=nothing, - key=nothing, - timeAdded=nothing, - value=nothing, - ) - - - effect::String : Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. - - key::String : Required. The taint key to be applied to a node. - - timeAdded::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - value::String : Required. The taint value corresponding to the taint key. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Taint <: OpenAPI.APIModel - effect::Union{Nothing, String} = nothing - key::Union{Nothing, String} = nothing - timeAdded::Union{Nothing, ZonedDateTime} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Taint(effect, key, timeAdded, value, ) - OpenAPI.validate_property(IoK8sApiCoreV1Taint, Symbol("effect"), effect) - OpenAPI.validate_property(IoK8sApiCoreV1Taint, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1Taint, Symbol("timeAdded"), timeAdded) - OpenAPI.validate_property(IoK8sApiCoreV1Taint, Symbol("value"), value) - return new(effect, key, timeAdded, value, ) - end -end # type IoK8sApiCoreV1Taint - -const _property_types_IoK8sApiCoreV1Taint = Dict{Symbol,String}(Symbol("effect")=>"String", Symbol("key")=>"String", Symbol("timeAdded")=>"ZonedDateTime", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Taint }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Taint[name]))} - -function check_required(o::IoK8sApiCoreV1Taint) - o.effect === nothing && (return false) - o.key === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Taint }, name::Symbol, val) - if name === Symbol("timeAdded") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Taint", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Toleration.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Toleration.jl deleted file mode 100644 index cbde8f05..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Toleration.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Toleration -The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>. - - IoK8sApiCoreV1Toleration(; - effect=nothing, - key=nothing, - operator=nothing, - tolerationSeconds=nothing, - value=nothing, - ) - - - effect::String : Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. - - key::String : Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. - - operator::String : Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. - - tolerationSeconds::Int64 : TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. - - value::String : Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Toleration <: OpenAPI.APIModel - effect::Union{Nothing, String} = nothing - key::Union{Nothing, String} = nothing - operator::Union{Nothing, String} = nothing - tolerationSeconds::Union{Nothing, Int64} = nothing - value::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1Toleration(effect, key, operator, tolerationSeconds, value, ) - OpenAPI.validate_property(IoK8sApiCoreV1Toleration, Symbol("effect"), effect) - OpenAPI.validate_property(IoK8sApiCoreV1Toleration, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1Toleration, Symbol("operator"), operator) - OpenAPI.validate_property(IoK8sApiCoreV1Toleration, Symbol("tolerationSeconds"), tolerationSeconds) - OpenAPI.validate_property(IoK8sApiCoreV1Toleration, Symbol("value"), value) - return new(effect, key, operator, tolerationSeconds, value, ) - end -end # type IoK8sApiCoreV1Toleration - -const _property_types_IoK8sApiCoreV1Toleration = Dict{Symbol,String}(Symbol("effect")=>"String", Symbol("key")=>"String", Symbol("operator")=>"String", Symbol("tolerationSeconds")=>"Int64", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Toleration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Toleration[name]))} - -function check_required(o::IoK8sApiCoreV1Toleration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Toleration }, name::Symbol, val) - if name === Symbol("tolerationSeconds") - OpenAPI.validate_param(name, "IoK8sApiCoreV1Toleration", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorLabelRequirement.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorLabelRequirement.jl deleted file mode 100644 index 2907c46c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorLabelRequirement.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.TopologySelectorLabelRequirement -A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future. - - IoK8sApiCoreV1TopologySelectorLabelRequirement(; - key=nothing, - values=nothing, - ) - - - key::String : The label key that the selector applies to. - - values::Vector{String} : An array of string values. One value must match the label to be selected. Each entry in Values is ORed. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1TopologySelectorLabelRequirement <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - values::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiCoreV1TopologySelectorLabelRequirement(key, values, ) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySelectorLabelRequirement, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySelectorLabelRequirement, Symbol("values"), values) - return new(key, values, ) - end -end # type IoK8sApiCoreV1TopologySelectorLabelRequirement - -const _property_types_IoK8sApiCoreV1TopologySelectorLabelRequirement = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("values")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1TopologySelectorLabelRequirement }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1TopologySelectorLabelRequirement[name]))} - -function check_required(o::IoK8sApiCoreV1TopologySelectorLabelRequirement) - o.key === nothing && (return false) - o.values === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1TopologySelectorLabelRequirement }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorTerm.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorTerm.jl deleted file mode 100644 index 331fccc1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySelectorTerm.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.TopologySelectorTerm -A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future. - - IoK8sApiCoreV1TopologySelectorTerm(; - matchLabelExpressions=nothing, - ) - - - matchLabelExpressions::Vector{IoK8sApiCoreV1TopologySelectorLabelRequirement} : A list of topology selector requirements by labels. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1TopologySelectorTerm <: OpenAPI.APIModel - matchLabelExpressions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1TopologySelectorLabelRequirement} } - - function IoK8sApiCoreV1TopologySelectorTerm(matchLabelExpressions, ) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySelectorTerm, Symbol("matchLabelExpressions"), matchLabelExpressions) - return new(matchLabelExpressions, ) - end -end # type IoK8sApiCoreV1TopologySelectorTerm - -const _property_types_IoK8sApiCoreV1TopologySelectorTerm = Dict{Symbol,String}(Symbol("matchLabelExpressions")=>"Vector{IoK8sApiCoreV1TopologySelectorLabelRequirement}", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1TopologySelectorTerm }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1TopologySelectorTerm[name]))} - -function check_required(o::IoK8sApiCoreV1TopologySelectorTerm) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1TopologySelectorTerm }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySpreadConstraint.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySpreadConstraint.jl deleted file mode 100644 index b89684ee..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TopologySpreadConstraint.jl +++ /dev/null @@ -1,49 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.TopologySpreadConstraint -TopologySpreadConstraint specifies how to spread matching pods among the given topology. - - IoK8sApiCoreV1TopologySpreadConstraint(; - labelSelector=nothing, - maxSkew=nothing, - topologyKey=nothing, - whenUnsatisfiable=nothing, - ) - - - labelSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - maxSkew::Int64 : MaxSkew describes the degree to which pods may be unevenly distributed. It's the maximum permitted difference between the number of matching pods in any two topology domains of a given topology type. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. It's a required field. Default value is 1 and 0 is not allowed. - - topologyKey::String : TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field. - - whenUnsatisfiable::String : WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it - ScheduleAnyway tells the scheduler to still schedule it It's considered as \"Unsatisfiable\" if and only if placing incoming pod on any topology violates \"MaxSkew\". For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1TopologySpreadConstraint <: OpenAPI.APIModel - labelSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - maxSkew::Union{Nothing, Int64} = nothing - topologyKey::Union{Nothing, String} = nothing - whenUnsatisfiable::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1TopologySpreadConstraint(labelSelector, maxSkew, topologyKey, whenUnsatisfiable, ) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySpreadConstraint, Symbol("labelSelector"), labelSelector) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySpreadConstraint, Symbol("maxSkew"), maxSkew) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySpreadConstraint, Symbol("topologyKey"), topologyKey) - OpenAPI.validate_property(IoK8sApiCoreV1TopologySpreadConstraint, Symbol("whenUnsatisfiable"), whenUnsatisfiable) - return new(labelSelector, maxSkew, topologyKey, whenUnsatisfiable, ) - end -end # type IoK8sApiCoreV1TopologySpreadConstraint - -const _property_types_IoK8sApiCoreV1TopologySpreadConstraint = Dict{Symbol,String}(Symbol("labelSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("maxSkew")=>"Int64", Symbol("topologyKey")=>"String", Symbol("whenUnsatisfiable")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1TopologySpreadConstraint }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1TopologySpreadConstraint[name]))} - -function check_required(o::IoK8sApiCoreV1TopologySpreadConstraint) - o.maxSkew === nothing && (return false) - o.topologyKey === nothing && (return false) - o.whenUnsatisfiable === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1TopologySpreadConstraint }, name::Symbol, val) - if name === Symbol("maxSkew") - OpenAPI.validate_param(name, "IoK8sApiCoreV1TopologySpreadConstraint", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TypedLocalObjectReference.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1TypedLocalObjectReference.jl deleted file mode 100644 index 5ff3bc8e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1TypedLocalObjectReference.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.TypedLocalObjectReference -TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace. - - IoK8sApiCoreV1TypedLocalObjectReference(; - apiGroup=nothing, - kind=nothing, - name=nothing, - ) - - - apiGroup::String : APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. - - kind::String : Kind is the type of resource being referenced - - name::String : Name is the name of resource being referenced -""" -Base.@kwdef mutable struct IoK8sApiCoreV1TypedLocalObjectReference <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1TypedLocalObjectReference(apiGroup, kind, name, ) - OpenAPI.validate_property(IoK8sApiCoreV1TypedLocalObjectReference, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiCoreV1TypedLocalObjectReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCoreV1TypedLocalObjectReference, Symbol("name"), name) - return new(apiGroup, kind, name, ) - end -end # type IoK8sApiCoreV1TypedLocalObjectReference - -const _property_types_IoK8sApiCoreV1TypedLocalObjectReference = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1TypedLocalObjectReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1TypedLocalObjectReference[name]))} - -function check_required(o::IoK8sApiCoreV1TypedLocalObjectReference) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1TypedLocalObjectReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Volume.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1Volume.jl deleted file mode 100644 index 689713d3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1Volume.jl +++ /dev/null @@ -1,144 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.Volume -Volume represents a named volume in a pod that may be accessed by any container in the pod. - - IoK8sApiCoreV1Volume(; - awsElasticBlockStore=nothing, - azureDisk=nothing, - azureFile=nothing, - cephfs=nothing, - cinder=nothing, - configMap=nothing, - csi=nothing, - downwardAPI=nothing, - emptyDir=nothing, - fc=nothing, - flexVolume=nothing, - flocker=nothing, - gcePersistentDisk=nothing, - gitRepo=nothing, - glusterfs=nothing, - hostPath=nothing, - iscsi=nothing, - name=nothing, - nfs=nothing, - persistentVolumeClaim=nothing, - photonPersistentDisk=nothing, - portworxVolume=nothing, - projected=nothing, - quobyte=nothing, - rbd=nothing, - scaleIO=nothing, - secret=nothing, - storageos=nothing, - vsphereVolume=nothing, - ) - - - awsElasticBlockStore::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - - azureDisk::IoK8sApiCoreV1AzureDiskVolumeSource - - azureFile::IoK8sApiCoreV1AzureFileVolumeSource - - cephfs::IoK8sApiCoreV1CephFSVolumeSource - - cinder::IoK8sApiCoreV1CinderVolumeSource - - configMap::IoK8sApiCoreV1ConfigMapVolumeSource - - csi::IoK8sApiCoreV1CSIVolumeSource - - downwardAPI::IoK8sApiCoreV1DownwardAPIVolumeSource - - emptyDir::IoK8sApiCoreV1EmptyDirVolumeSource - - fc::IoK8sApiCoreV1FCVolumeSource - - flexVolume::IoK8sApiCoreV1FlexVolumeSource - - flocker::IoK8sApiCoreV1FlockerVolumeSource - - gcePersistentDisk::IoK8sApiCoreV1GCEPersistentDiskVolumeSource - - gitRepo::IoK8sApiCoreV1GitRepoVolumeSource - - glusterfs::IoK8sApiCoreV1GlusterfsVolumeSource - - hostPath::IoK8sApiCoreV1HostPathVolumeSource - - iscsi::IoK8sApiCoreV1ISCSIVolumeSource - - name::String : Volume's name. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names - - nfs::IoK8sApiCoreV1NFSVolumeSource - - persistentVolumeClaim::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - - photonPersistentDisk::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - - portworxVolume::IoK8sApiCoreV1PortworxVolumeSource - - projected::IoK8sApiCoreV1ProjectedVolumeSource - - quobyte::IoK8sApiCoreV1QuobyteVolumeSource - - rbd::IoK8sApiCoreV1RBDVolumeSource - - scaleIO::IoK8sApiCoreV1ScaleIOVolumeSource - - secret::IoK8sApiCoreV1SecretVolumeSource - - storageos::IoK8sApiCoreV1StorageOSVolumeSource - - vsphereVolume::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource -""" -Base.@kwdef mutable struct IoK8sApiCoreV1Volume <: OpenAPI.APIModel - awsElasticBlockStore = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource } - azureDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AzureDiskVolumeSource } - azureFile = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1AzureFileVolumeSource } - cephfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CephFSVolumeSource } - cinder = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CinderVolumeSource } - configMap = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ConfigMapVolumeSource } - csi = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1CSIVolumeSource } - downwardAPI = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1DownwardAPIVolumeSource } - emptyDir = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1EmptyDirVolumeSource } - fc = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FCVolumeSource } - flexVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FlexVolumeSource } - flocker = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1FlockerVolumeSource } - gcePersistentDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1GCEPersistentDiskVolumeSource } - gitRepo = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1GitRepoVolumeSource } - glusterfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1GlusterfsVolumeSource } - hostPath = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1HostPathVolumeSource } - iscsi = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ISCSIVolumeSource } - name::Union{Nothing, String} = nothing - nfs = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NFSVolumeSource } - persistentVolumeClaim = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeClaimVolumeSource } - photonPersistentDisk = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PhotonPersistentDiskVolumeSource } - portworxVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PortworxVolumeSource } - projected = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ProjectedVolumeSource } - quobyte = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1QuobyteVolumeSource } - rbd = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1RBDVolumeSource } - scaleIO = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ScaleIOVolumeSource } - secret = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretVolumeSource } - storageos = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1StorageOSVolumeSource } - vsphereVolume = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1VsphereVirtualDiskVolumeSource } - - function IoK8sApiCoreV1Volume(awsElasticBlockStore, azureDisk, azureFile, cephfs, cinder, configMap, csi, downwardAPI, emptyDir, fc, flexVolume, flocker, gcePersistentDisk, gitRepo, glusterfs, hostPath, iscsi, name, nfs, persistentVolumeClaim, photonPersistentDisk, portworxVolume, projected, quobyte, rbd, scaleIO, secret, storageos, vsphereVolume, ) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("awsElasticBlockStore"), awsElasticBlockStore) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("azureDisk"), azureDisk) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("azureFile"), azureFile) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("cephfs"), cephfs) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("cinder"), cinder) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("configMap"), configMap) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("csi"), csi) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("downwardAPI"), downwardAPI) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("emptyDir"), emptyDir) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("fc"), fc) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("flexVolume"), flexVolume) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("flocker"), flocker) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("gcePersistentDisk"), gcePersistentDisk) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("gitRepo"), gitRepo) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("glusterfs"), glusterfs) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("hostPath"), hostPath) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("iscsi"), iscsi) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("nfs"), nfs) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("persistentVolumeClaim"), persistentVolumeClaim) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("photonPersistentDisk"), photonPersistentDisk) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("portworxVolume"), portworxVolume) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("projected"), projected) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("quobyte"), quobyte) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("rbd"), rbd) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("scaleIO"), scaleIO) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("secret"), secret) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("storageos"), storageos) - OpenAPI.validate_property(IoK8sApiCoreV1Volume, Symbol("vsphereVolume"), vsphereVolume) - return new(awsElasticBlockStore, azureDisk, azureFile, cephfs, cinder, configMap, csi, downwardAPI, emptyDir, fc, flexVolume, flocker, gcePersistentDisk, gitRepo, glusterfs, hostPath, iscsi, name, nfs, persistentVolumeClaim, photonPersistentDisk, portworxVolume, projected, quobyte, rbd, scaleIO, secret, storageos, vsphereVolume, ) - end -end # type IoK8sApiCoreV1Volume - -const _property_types_IoK8sApiCoreV1Volume = Dict{Symbol,String}(Symbol("awsElasticBlockStore")=>"IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource", Symbol("azureDisk")=>"IoK8sApiCoreV1AzureDiskVolumeSource", Symbol("azureFile")=>"IoK8sApiCoreV1AzureFileVolumeSource", Symbol("cephfs")=>"IoK8sApiCoreV1CephFSVolumeSource", Symbol("cinder")=>"IoK8sApiCoreV1CinderVolumeSource", Symbol("configMap")=>"IoK8sApiCoreV1ConfigMapVolumeSource", Symbol("csi")=>"IoK8sApiCoreV1CSIVolumeSource", Symbol("downwardAPI")=>"IoK8sApiCoreV1DownwardAPIVolumeSource", Symbol("emptyDir")=>"IoK8sApiCoreV1EmptyDirVolumeSource", Symbol("fc")=>"IoK8sApiCoreV1FCVolumeSource", Symbol("flexVolume")=>"IoK8sApiCoreV1FlexVolumeSource", Symbol("flocker")=>"IoK8sApiCoreV1FlockerVolumeSource", Symbol("gcePersistentDisk")=>"IoK8sApiCoreV1GCEPersistentDiskVolumeSource", Symbol("gitRepo")=>"IoK8sApiCoreV1GitRepoVolumeSource", Symbol("glusterfs")=>"IoK8sApiCoreV1GlusterfsVolumeSource", Symbol("hostPath")=>"IoK8sApiCoreV1HostPathVolumeSource", Symbol("iscsi")=>"IoK8sApiCoreV1ISCSIVolumeSource", Symbol("name")=>"String", Symbol("nfs")=>"IoK8sApiCoreV1NFSVolumeSource", Symbol("persistentVolumeClaim")=>"IoK8sApiCoreV1PersistentVolumeClaimVolumeSource", Symbol("photonPersistentDisk")=>"IoK8sApiCoreV1PhotonPersistentDiskVolumeSource", Symbol("portworxVolume")=>"IoK8sApiCoreV1PortworxVolumeSource", Symbol("projected")=>"IoK8sApiCoreV1ProjectedVolumeSource", Symbol("quobyte")=>"IoK8sApiCoreV1QuobyteVolumeSource", Symbol("rbd")=>"IoK8sApiCoreV1RBDVolumeSource", Symbol("scaleIO")=>"IoK8sApiCoreV1ScaleIOVolumeSource", Symbol("secret")=>"IoK8sApiCoreV1SecretVolumeSource", Symbol("storageos")=>"IoK8sApiCoreV1StorageOSVolumeSource", Symbol("vsphereVolume")=>"IoK8sApiCoreV1VsphereVirtualDiskVolumeSource", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1Volume }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1Volume[name]))} - -function check_required(o::IoK8sApiCoreV1Volume) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1Volume }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeDevice.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeDevice.jl deleted file mode 100644 index da418300..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeDevice.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.VolumeDevice -volumeDevice describes a mapping of a raw block device within a container. - - IoK8sApiCoreV1VolumeDevice(; - devicePath=nothing, - name=nothing, - ) - - - devicePath::String : devicePath is the path inside of the container that the device will be mapped to. - - name::String : name must match the name of a persistentVolumeClaim in the pod -""" -Base.@kwdef mutable struct IoK8sApiCoreV1VolumeDevice <: OpenAPI.APIModel - devicePath::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1VolumeDevice(devicePath, name, ) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeDevice, Symbol("devicePath"), devicePath) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeDevice, Symbol("name"), name) - return new(devicePath, name, ) - end -end # type IoK8sApiCoreV1VolumeDevice - -const _property_types_IoK8sApiCoreV1VolumeDevice = Dict{Symbol,String}(Symbol("devicePath")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1VolumeDevice }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1VolumeDevice[name]))} - -function check_required(o::IoK8sApiCoreV1VolumeDevice) - o.devicePath === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1VolumeDevice }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeMount.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeMount.jl deleted file mode 100644 index 23c0db53..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeMount.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.VolumeMount -VolumeMount describes a mounting of a Volume within a container. - - IoK8sApiCoreV1VolumeMount(; - mountPath=nothing, - mountPropagation=nothing, - name=nothing, - readOnly=nothing, - subPath=nothing, - subPathExpr=nothing, - ) - - - mountPath::String : Path within the container at which the volume should be mounted. Must not contain ':'. - - mountPropagation::String : mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. - - name::String : This must match the Name of a Volume. - - readOnly::Bool : Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. - - subPath::String : Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root). - - subPathExpr::String : Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1VolumeMount <: OpenAPI.APIModel - mountPath::Union{Nothing, String} = nothing - mountPropagation::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - subPath::Union{Nothing, String} = nothing - subPathExpr::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1VolumeMount(mountPath, mountPropagation, name, readOnly, subPath, subPathExpr, ) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("mountPath"), mountPath) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("mountPropagation"), mountPropagation) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("readOnly"), readOnly) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("subPath"), subPath) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeMount, Symbol("subPathExpr"), subPathExpr) - return new(mountPath, mountPropagation, name, readOnly, subPath, subPathExpr, ) - end -end # type IoK8sApiCoreV1VolumeMount - -const _property_types_IoK8sApiCoreV1VolumeMount = Dict{Symbol,String}(Symbol("mountPath")=>"String", Symbol("mountPropagation")=>"String", Symbol("name")=>"String", Symbol("readOnly")=>"Bool", Symbol("subPath")=>"String", Symbol("subPathExpr")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1VolumeMount }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1VolumeMount[name]))} - -function check_required(o::IoK8sApiCoreV1VolumeMount) - o.mountPath === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1VolumeMount }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeNodeAffinity.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeNodeAffinity.jl deleted file mode 100644 index 6584ba26..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeNodeAffinity.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.VolumeNodeAffinity -VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from. - - IoK8sApiCoreV1VolumeNodeAffinity(; - required=nothing, - ) - - - required::IoK8sApiCoreV1NodeSelector -""" -Base.@kwdef mutable struct IoK8sApiCoreV1VolumeNodeAffinity <: OpenAPI.APIModel - required = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1NodeSelector } - - function IoK8sApiCoreV1VolumeNodeAffinity(required, ) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeNodeAffinity, Symbol("required"), required) - return new(required, ) - end -end # type IoK8sApiCoreV1VolumeNodeAffinity - -const _property_types_IoK8sApiCoreV1VolumeNodeAffinity = Dict{Symbol,String}(Symbol("required")=>"IoK8sApiCoreV1NodeSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1VolumeNodeAffinity }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1VolumeNodeAffinity[name]))} - -function check_required(o::IoK8sApiCoreV1VolumeNodeAffinity) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1VolumeNodeAffinity }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeProjection.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeProjection.jl deleted file mode 100644 index da19725a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VolumeProjection.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.VolumeProjection -Projection that may be projected along with other supported volume types - - IoK8sApiCoreV1VolumeProjection(; - configMap=nothing, - downwardAPI=nothing, - secret=nothing, - serviceAccountToken=nothing, - ) - - - configMap::IoK8sApiCoreV1ConfigMapProjection - - downwardAPI::IoK8sApiCoreV1DownwardAPIProjection - - secret::IoK8sApiCoreV1SecretProjection - - serviceAccountToken::IoK8sApiCoreV1ServiceAccountTokenProjection -""" -Base.@kwdef mutable struct IoK8sApiCoreV1VolumeProjection <: OpenAPI.APIModel - configMap = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ConfigMapProjection } - downwardAPI = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1DownwardAPIProjection } - secret = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SecretProjection } - serviceAccountToken = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ServiceAccountTokenProjection } - - function IoK8sApiCoreV1VolumeProjection(configMap, downwardAPI, secret, serviceAccountToken, ) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeProjection, Symbol("configMap"), configMap) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeProjection, Symbol("downwardAPI"), downwardAPI) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeProjection, Symbol("secret"), secret) - OpenAPI.validate_property(IoK8sApiCoreV1VolumeProjection, Symbol("serviceAccountToken"), serviceAccountToken) - return new(configMap, downwardAPI, secret, serviceAccountToken, ) - end -end # type IoK8sApiCoreV1VolumeProjection - -const _property_types_IoK8sApiCoreV1VolumeProjection = Dict{Symbol,String}(Symbol("configMap")=>"IoK8sApiCoreV1ConfigMapProjection", Symbol("downwardAPI")=>"IoK8sApiCoreV1DownwardAPIProjection", Symbol("secret")=>"IoK8sApiCoreV1SecretProjection", Symbol("serviceAccountToken")=>"IoK8sApiCoreV1ServiceAccountTokenProjection", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1VolumeProjection }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1VolumeProjection[name]))} - -function check_required(o::IoK8sApiCoreV1VolumeProjection) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1VolumeProjection }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource.jl deleted file mode 100644 index acfd11f3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource -Represents a vSphere volume resource. - - IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(; - fsType=nothing, - storagePolicyID=nothing, - storagePolicyName=nothing, - volumePath=nothing, - ) - - - fsType::String : Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. - - storagePolicyID::String : Storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. - - storagePolicyName::String : Storage Policy Based Management (SPBM) profile name. - - volumePath::String : Path that identifies vSphere volume vmdk -""" -Base.@kwdef mutable struct IoK8sApiCoreV1VsphereVirtualDiskVolumeSource <: OpenAPI.APIModel - fsType::Union{Nothing, String} = nothing - storagePolicyID::Union{Nothing, String} = nothing - storagePolicyName::Union{Nothing, String} = nothing - volumePath::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(fsType, storagePolicyID, storagePolicyName, volumePath, ) - OpenAPI.validate_property(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, Symbol("fsType"), fsType) - OpenAPI.validate_property(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, Symbol("storagePolicyID"), storagePolicyID) - OpenAPI.validate_property(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, Symbol("storagePolicyName"), storagePolicyName) - OpenAPI.validate_property(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, Symbol("volumePath"), volumePath) - return new(fsType, storagePolicyID, storagePolicyName, volumePath, ) - end -end # type IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - -const _property_types_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource = Dict{Symbol,String}(Symbol("fsType")=>"String", Symbol("storagePolicyID")=>"String", Symbol("storagePolicyName")=>"String", Symbol("volumePath")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1VsphereVirtualDiskVolumeSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1VsphereVirtualDiskVolumeSource[name]))} - -function check_required(o::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) - o.volumePath === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1VsphereVirtualDiskVolumeSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1WeightedPodAffinityTerm.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1WeightedPodAffinityTerm.jl deleted file mode 100644 index 794ed0fe..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1WeightedPodAffinityTerm.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.WeightedPodAffinityTerm -The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) - - IoK8sApiCoreV1WeightedPodAffinityTerm(; - podAffinityTerm=nothing, - weight=nothing, - ) - - - podAffinityTerm::IoK8sApiCoreV1PodAffinityTerm - - weight::Int64 : weight associated with matching the corresponding podAffinityTerm, in the range 1-100. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1WeightedPodAffinityTerm <: OpenAPI.APIModel - podAffinityTerm = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodAffinityTerm } - weight::Union{Nothing, Int64} = nothing - - function IoK8sApiCoreV1WeightedPodAffinityTerm(podAffinityTerm, weight, ) - OpenAPI.validate_property(IoK8sApiCoreV1WeightedPodAffinityTerm, Symbol("podAffinityTerm"), podAffinityTerm) - OpenAPI.validate_property(IoK8sApiCoreV1WeightedPodAffinityTerm, Symbol("weight"), weight) - return new(podAffinityTerm, weight, ) - end -end # type IoK8sApiCoreV1WeightedPodAffinityTerm - -const _property_types_IoK8sApiCoreV1WeightedPodAffinityTerm = Dict{Symbol,String}(Symbol("podAffinityTerm")=>"IoK8sApiCoreV1PodAffinityTerm", Symbol("weight")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1WeightedPodAffinityTerm }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1WeightedPodAffinityTerm[name]))} - -function check_required(o::IoK8sApiCoreV1WeightedPodAffinityTerm) - o.podAffinityTerm === nothing && (return false) - o.weight === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1WeightedPodAffinityTerm }, name::Symbol, val) - if name === Symbol("weight") - OpenAPI.validate_param(name, "IoK8sApiCoreV1WeightedPodAffinityTerm", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCoreV1WindowsSecurityContextOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiCoreV1WindowsSecurityContextOptions.jl deleted file mode 100644 index 57d477e1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCoreV1WindowsSecurityContextOptions.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.core.v1.WindowsSecurityContextOptions -WindowsSecurityContextOptions contain Windows-specific options and credentials. - - IoK8sApiCoreV1WindowsSecurityContextOptions(; - gmsaCredentialSpec=nothing, - gmsaCredentialSpecName=nothing, - runAsUserName=nothing, - ) - - - gmsaCredentialSpec::String : GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. This field is alpha-level and is only honored by servers that enable the WindowsGMSA feature flag. - - gmsaCredentialSpecName::String : GMSACredentialSpecName is the name of the GMSA credential spec to use. This field is alpha-level and is only honored by servers that enable the WindowsGMSA feature flag. - - runAsUserName::String : The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. This field is beta-level and may be disabled with the WindowsRunAsUserName feature flag. -""" -Base.@kwdef mutable struct IoK8sApiCoreV1WindowsSecurityContextOptions <: OpenAPI.APIModel - gmsaCredentialSpec::Union{Nothing, String} = nothing - gmsaCredentialSpecName::Union{Nothing, String} = nothing - runAsUserName::Union{Nothing, String} = nothing - - function IoK8sApiCoreV1WindowsSecurityContextOptions(gmsaCredentialSpec, gmsaCredentialSpecName, runAsUserName, ) - OpenAPI.validate_property(IoK8sApiCoreV1WindowsSecurityContextOptions, Symbol("gmsaCredentialSpec"), gmsaCredentialSpec) - OpenAPI.validate_property(IoK8sApiCoreV1WindowsSecurityContextOptions, Symbol("gmsaCredentialSpecName"), gmsaCredentialSpecName) - OpenAPI.validate_property(IoK8sApiCoreV1WindowsSecurityContextOptions, Symbol("runAsUserName"), runAsUserName) - return new(gmsaCredentialSpec, gmsaCredentialSpecName, runAsUserName, ) - end -end # type IoK8sApiCoreV1WindowsSecurityContextOptions - -const _property_types_IoK8sApiCoreV1WindowsSecurityContextOptions = Dict{Symbol,String}(Symbol("gmsaCredentialSpec")=>"String", Symbol("gmsaCredentialSpecName")=>"String", Symbol("runAsUserName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiCoreV1WindowsSecurityContextOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCoreV1WindowsSecurityContextOptions[name]))} - -function check_required(o::IoK8sApiCoreV1WindowsSecurityContextOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCoreV1WindowsSecurityContextOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValue.jl b/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValue.jl deleted file mode 100644 index 4f748249..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValue.jl +++ /dev/null @@ -1,61 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.custom.metrics.v1beta1.MetricValue -a metric value for some object - - IoK8sApiCustomMetricsV1beta1MetricValue(; - apiVersion=nothing, - describedObject=nothing, - kind=nothing, - metricName=nothing, - timestamp=nothing, - value=nothing, - windowSeconds=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - describedObject::IoK8sApiCoreV1ObjectReference - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metricName::String : the name of the metric - - timestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - value::String : Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors. The serialization format is: <quantity> ::= <signedNumber><suffix> (Note that <suffix> may be empty, from the \"\" case in <decimalSI>.) <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> | <digit><digits> <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign> ::= \"+\" | \"-\" <signedNumber> ::= <number> | <sign><number> <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) <decimalSI> ::= m | \"\" | k | M | G | T | P | E (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) <decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. Before serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: a. No precision is lost b. No fractional digits will be emitted c. The exponent (or suffix) is as large as possible. The sign will be omitted unless the number is negative. Examples: 1.5 will be serialized as \"1500m\" 1.5Gi will be serialized as \"1536Mi\" Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. - - windowSeconds::Int64 : indicates the window ([Timestamp-Window, Timestamp]) from which these metrics were calculated, when returning rate metrics calculated from cumulative metrics (or zero for non-calculated instantaneous metrics). -""" -Base.@kwdef mutable struct IoK8sApiCustomMetricsV1beta1MetricValue <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - describedObject = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - kind::Union{Nothing, String} = nothing - metricName::Union{Nothing, String} = nothing - timestamp::Union{Nothing, ZonedDateTime} = nothing - value::Union{Nothing, String} = nothing - windowSeconds::Union{Nothing, Int64} = nothing - - function IoK8sApiCustomMetricsV1beta1MetricValue(apiVersion, describedObject, kind, metricName, timestamp, value, windowSeconds, ) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("describedObject"), describedObject) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("metricName"), metricName) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("timestamp"), timestamp) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("value"), value) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValue, Symbol("windowSeconds"), windowSeconds) - return new(apiVersion, describedObject, kind, metricName, timestamp, value, windowSeconds, ) - end -end # type IoK8sApiCustomMetricsV1beta1MetricValue - -const _property_types_IoK8sApiCustomMetricsV1beta1MetricValue = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("describedObject")=>"IoK8sApiCoreV1ObjectReference", Symbol("kind")=>"String", Symbol("metricName")=>"String", Symbol("timestamp")=>"ZonedDateTime", Symbol("value")=>"String", Symbol("windowSeconds")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiCustomMetricsV1beta1MetricValue }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCustomMetricsV1beta1MetricValue[name]))} - -function check_required(o::IoK8sApiCustomMetricsV1beta1MetricValue) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCustomMetricsV1beta1MetricValue }, name::Symbol, val) - if name === Symbol("timestamp") - OpenAPI.validate_param(name, "IoK8sApiCustomMetricsV1beta1MetricValue", :format, val, "date-time") - end - if name === Symbol("windowSeconds") - OpenAPI.validate_param(name, "IoK8sApiCustomMetricsV1beta1MetricValue", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValueList.jl b/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValueList.jl deleted file mode 100644 index 057cf84a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiCustomMetricsV1beta1MetricValueList.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.custom.metrics.v1beta1.MetricValueList -a list of values for a given metric for some set of objects - - IoK8sApiCustomMetricsV1beta1MetricValueList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiCustomMetricsV1beta1MetricValue} : the value of the metric across the described objects - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiCustomMetricsV1beta1MetricValueList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCustomMetricsV1beta1MetricValue} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiCustomMetricsV1beta1MetricValueList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValueList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValueList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValueList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiCustomMetricsV1beta1MetricValueList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiCustomMetricsV1beta1MetricValueList - -const _property_types_IoK8sApiCustomMetricsV1beta1MetricValueList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiCustomMetricsV1beta1MetricValue}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiCustomMetricsV1beta1MetricValueList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiCustomMetricsV1beta1MetricValueList[name]))} - -function check_required(o::IoK8sApiCustomMetricsV1beta1MetricValueList) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiCustomMetricsV1beta1MetricValueList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1Endpoint.jl b/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1Endpoint.jl deleted file mode 100644 index f858cb3f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1Endpoint.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.discovery.v1beta1.Endpoint -Endpoint represents a single logical \"backend\" implementing a service. - - IoK8sApiDiscoveryV1beta1Endpoint(; - addresses=nothing, - conditions=nothing, - hostname=nothing, - targetRef=nothing, - topology=nothing, - ) - - - addresses::Vector{String} : addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. - - conditions::IoK8sApiDiscoveryV1beta1EndpointConditions - - hostname::String : hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must pass DNS Label (RFC 1123) validation. - - targetRef::IoK8sApiCoreV1ObjectReference - - topology::Dict{String, String} : topology contains arbitrary topology information associated with the endpoint. These key/value pairs must conform with the label format. https://kubernetes.io/docs/concepts/overview/working-with-objects/labels Topology may include a maximum of 16 key/value pairs. This includes, but is not limited to the following well known keys: * kubernetes.io/hostname: the value indicates the hostname of the node where the endpoint is located. This should match the corresponding node label. * topology.kubernetes.io/zone: the value indicates the zone where the endpoint is located. This should match the corresponding node label. * topology.kubernetes.io/region: the value indicates the region where the endpoint is located. This should match the corresponding node label. -""" -Base.@kwdef mutable struct IoK8sApiDiscoveryV1beta1Endpoint <: OpenAPI.APIModel - addresses::Union{Nothing, Vector{String}} = nothing - conditions = nothing # spec type: Union{ Nothing, IoK8sApiDiscoveryV1beta1EndpointConditions } - hostname::Union{Nothing, String} = nothing - targetRef = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - topology::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiDiscoveryV1beta1Endpoint(addresses, conditions, hostname, targetRef, topology, ) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1Endpoint, Symbol("addresses"), addresses) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1Endpoint, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1Endpoint, Symbol("hostname"), hostname) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1Endpoint, Symbol("targetRef"), targetRef) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1Endpoint, Symbol("topology"), topology) - return new(addresses, conditions, hostname, targetRef, topology, ) - end -end # type IoK8sApiDiscoveryV1beta1Endpoint - -const _property_types_IoK8sApiDiscoveryV1beta1Endpoint = Dict{Symbol,String}(Symbol("addresses")=>"Vector{String}", Symbol("conditions")=>"IoK8sApiDiscoveryV1beta1EndpointConditions", Symbol("hostname")=>"String", Symbol("targetRef")=>"IoK8sApiCoreV1ObjectReference", Symbol("topology")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiDiscoveryV1beta1Endpoint }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiDiscoveryV1beta1Endpoint[name]))} - -function check_required(o::IoK8sApiDiscoveryV1beta1Endpoint) - o.addresses === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiDiscoveryV1beta1Endpoint }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointConditions.jl b/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointConditions.jl deleted file mode 100644 index eaf844b0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointConditions.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.discovery.v1beta1.EndpointConditions -EndpointConditions represents the current condition of an endpoint. - - IoK8sApiDiscoveryV1beta1EndpointConditions(; - ready=nothing, - ) - - - ready::Bool : ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. -""" -Base.@kwdef mutable struct IoK8sApiDiscoveryV1beta1EndpointConditions <: OpenAPI.APIModel - ready::Union{Nothing, Bool} = nothing - - function IoK8sApiDiscoveryV1beta1EndpointConditions(ready, ) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointConditions, Symbol("ready"), ready) - return new(ready, ) - end -end # type IoK8sApiDiscoveryV1beta1EndpointConditions - -const _property_types_IoK8sApiDiscoveryV1beta1EndpointConditions = Dict{Symbol,String}(Symbol("ready")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiDiscoveryV1beta1EndpointConditions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiDiscoveryV1beta1EndpointConditions[name]))} - -function check_required(o::IoK8sApiDiscoveryV1beta1EndpointConditions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiDiscoveryV1beta1EndpointConditions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointPort.jl b/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointPort.jl deleted file mode 100644 index a681c0ca..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointPort.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.discovery.v1beta1.EndpointPort -EndpointPort represents a Port used by an EndpointSlice - - IoK8sApiDiscoveryV1beta1EndpointPort(; - appProtocol=nothing, - name=nothing, - port=nothing, - protocol=nothing, - ) - - - appProtocol::String : The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and http://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names. Default is empty string. - - name::String : The name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is dervied from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string. - - port::Int64 : The port number of the endpoint. If this is not specified, ports are not restricted and must be interpreted in the context of the specific consumer. - - protocol::String : The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP. -""" -Base.@kwdef mutable struct IoK8sApiDiscoveryV1beta1EndpointPort <: OpenAPI.APIModel - appProtocol::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - protocol::Union{Nothing, String} = nothing - - function IoK8sApiDiscoveryV1beta1EndpointPort(appProtocol, name, port, protocol, ) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointPort, Symbol("appProtocol"), appProtocol) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointPort, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointPort, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointPort, Symbol("protocol"), protocol) - return new(appProtocol, name, port, protocol, ) - end -end # type IoK8sApiDiscoveryV1beta1EndpointPort - -const _property_types_IoK8sApiDiscoveryV1beta1EndpointPort = Dict{Symbol,String}(Symbol("appProtocol")=>"String", Symbol("name")=>"String", Symbol("port")=>"Int64", Symbol("protocol")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiDiscoveryV1beta1EndpointPort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiDiscoveryV1beta1EndpointPort[name]))} - -function check_required(o::IoK8sApiDiscoveryV1beta1EndpointPort) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiDiscoveryV1beta1EndpointPort }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiDiscoveryV1beta1EndpointPort", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSlice.jl b/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSlice.jl deleted file mode 100644 index 8c61af56..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSlice.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.discovery.v1beta1.EndpointSlice -EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. - - IoK8sApiDiscoveryV1beta1EndpointSlice(; - addressType=nothing, - apiVersion=nothing, - endpoints=nothing, - kind=nothing, - metadata=nothing, - ports=nothing, - ) - - - addressType::String : addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - endpoints::Vector{IoK8sApiDiscoveryV1beta1Endpoint} : endpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - ports::Vector{IoK8sApiDiscoveryV1beta1EndpointPort} : ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. When ports is empty, it indicates that there are no defined ports. When a port is defined with a nil port value, it indicates \"all ports\". Each slice may include a maximum of 100 ports. -""" -Base.@kwdef mutable struct IoK8sApiDiscoveryV1beta1EndpointSlice <: OpenAPI.APIModel - addressType::Union{Nothing, String} = nothing - apiVersion::Union{Nothing, String} = nothing - endpoints::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiDiscoveryV1beta1Endpoint} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiDiscoveryV1beta1EndpointPort} } - - function IoK8sApiDiscoveryV1beta1EndpointSlice(addressType, apiVersion, endpoints, kind, metadata, ports, ) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("addressType"), addressType) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("endpoints"), endpoints) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSlice, Symbol("ports"), ports) - return new(addressType, apiVersion, endpoints, kind, metadata, ports, ) - end -end # type IoK8sApiDiscoveryV1beta1EndpointSlice - -const _property_types_IoK8sApiDiscoveryV1beta1EndpointSlice = Dict{Symbol,String}(Symbol("addressType")=>"String", Symbol("apiVersion")=>"String", Symbol("endpoints")=>"Vector{IoK8sApiDiscoveryV1beta1Endpoint}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("ports")=>"Vector{IoK8sApiDiscoveryV1beta1EndpointPort}", ) -OpenAPI.property_type(::Type{ IoK8sApiDiscoveryV1beta1EndpointSlice }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiDiscoveryV1beta1EndpointSlice[name]))} - -function check_required(o::IoK8sApiDiscoveryV1beta1EndpointSlice) - o.addressType === nothing && (return false) - o.endpoints === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiDiscoveryV1beta1EndpointSlice }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSliceList.jl b/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSliceList.jl deleted file mode 100644 index 4c02eb8c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiDiscoveryV1beta1EndpointSliceList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.discovery.v1beta1.EndpointSliceList -EndpointSliceList represents a list of endpoint slices - - IoK8sApiDiscoveryV1beta1EndpointSliceList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiDiscoveryV1beta1EndpointSlice} : List of endpoint slices - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiDiscoveryV1beta1EndpointSliceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiDiscoveryV1beta1EndpointSlice} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiDiscoveryV1beta1EndpointSliceList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSliceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSliceList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSliceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiDiscoveryV1beta1EndpointSliceList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiDiscoveryV1beta1EndpointSliceList - -const _property_types_IoK8sApiDiscoveryV1beta1EndpointSliceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiDiscoveryV1beta1EndpointSlice}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiDiscoveryV1beta1EndpointSliceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiDiscoveryV1beta1EndpointSliceList[name]))} - -function check_required(o::IoK8sApiDiscoveryV1beta1EndpointSliceList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiDiscoveryV1beta1EndpointSliceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1Event.jl b/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1Event.jl deleted file mode 100644 index 6797953c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1Event.jl +++ /dev/null @@ -1,108 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.events.v1beta1.Event -Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. - - IoK8sApiEventsV1beta1Event(; - action=nothing, - apiVersion=nothing, - deprecatedCount=nothing, - deprecatedFirstTimestamp=nothing, - deprecatedLastTimestamp=nothing, - deprecatedSource=nothing, - eventTime=nothing, - kind=nothing, - metadata=nothing, - note=nothing, - reason=nothing, - regarding=nothing, - related=nothing, - reportingController=nothing, - reportingInstance=nothing, - series=nothing, - type=nothing, - ) - - - action::String : What action was taken/failed regarding to the regarding object. - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - deprecatedCount::Int64 : Deprecated field assuring backward compatibility with core.v1 Event type - - deprecatedFirstTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - deprecatedLastTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - deprecatedSource::IoK8sApiCoreV1EventSource - - eventTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - note::String : Optional. A human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB. - - reason::String : Why the action was taken. - - regarding::IoK8sApiCoreV1ObjectReference - - related::IoK8sApiCoreV1ObjectReference - - reportingController::String : Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. - - reportingInstance::String : ID of the controller instance, e.g. `kubelet-xyzf`. - - series::IoK8sApiEventsV1beta1EventSeries - - type::String : Type of this event (Normal, Warning), new types could be added in the future. -""" -Base.@kwdef mutable struct IoK8sApiEventsV1beta1Event <: OpenAPI.APIModel - action::Union{Nothing, String} = nothing - apiVersion::Union{Nothing, String} = nothing - deprecatedCount::Union{Nothing, Int64} = nothing - deprecatedFirstTimestamp::Union{Nothing, ZonedDateTime} = nothing - deprecatedLastTimestamp::Union{Nothing, ZonedDateTime} = nothing - deprecatedSource = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1EventSource } - eventTime::Union{Nothing, ZonedDateTime} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - note::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - regarding = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - related = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1ObjectReference } - reportingController::Union{Nothing, String} = nothing - reportingInstance::Union{Nothing, String} = nothing - series = nothing # spec type: Union{ Nothing, IoK8sApiEventsV1beta1EventSeries } - type::Union{Nothing, String} = nothing - - function IoK8sApiEventsV1beta1Event(action, apiVersion, deprecatedCount, deprecatedFirstTimestamp, deprecatedLastTimestamp, deprecatedSource, eventTime, kind, metadata, note, reason, regarding, related, reportingController, reportingInstance, series, type, ) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("action"), action) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("deprecatedCount"), deprecatedCount) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("deprecatedFirstTimestamp"), deprecatedFirstTimestamp) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("deprecatedLastTimestamp"), deprecatedLastTimestamp) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("deprecatedSource"), deprecatedSource) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("eventTime"), eventTime) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("note"), note) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("regarding"), regarding) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("related"), related) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("reportingController"), reportingController) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("reportingInstance"), reportingInstance) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("series"), series) - OpenAPI.validate_property(IoK8sApiEventsV1beta1Event, Symbol("type"), type) - return new(action, apiVersion, deprecatedCount, deprecatedFirstTimestamp, deprecatedLastTimestamp, deprecatedSource, eventTime, kind, metadata, note, reason, regarding, related, reportingController, reportingInstance, series, type, ) - end -end # type IoK8sApiEventsV1beta1Event - -const _property_types_IoK8sApiEventsV1beta1Event = Dict{Symbol,String}(Symbol("action")=>"String", Symbol("apiVersion")=>"String", Symbol("deprecatedCount")=>"Int64", Symbol("deprecatedFirstTimestamp")=>"ZonedDateTime", Symbol("deprecatedLastTimestamp")=>"ZonedDateTime", Symbol("deprecatedSource")=>"IoK8sApiCoreV1EventSource", Symbol("eventTime")=>"ZonedDateTime", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("note")=>"String", Symbol("reason")=>"String", Symbol("regarding")=>"IoK8sApiCoreV1ObjectReference", Symbol("related")=>"IoK8sApiCoreV1ObjectReference", Symbol("reportingController")=>"String", Symbol("reportingInstance")=>"String", Symbol("series")=>"IoK8sApiEventsV1beta1EventSeries", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiEventsV1beta1Event }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiEventsV1beta1Event[name]))} - -function check_required(o::IoK8sApiEventsV1beta1Event) - o.eventTime === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiEventsV1beta1Event }, name::Symbol, val) - if name === Symbol("deprecatedCount") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1Event", :format, val, "int32") - end - if name === Symbol("deprecatedFirstTimestamp") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1Event", :format, val, "date-time") - end - if name === Symbol("deprecatedLastTimestamp") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1Event", :format, val, "date-time") - end - if name === Symbol("eventTime") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1Event", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventList.jl b/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventList.jl deleted file mode 100644 index c86b3784..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.events.v1beta1.EventList -EventList is a list of Event objects. - - IoK8sApiEventsV1beta1EventList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiEventsV1beta1Event} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiEventsV1beta1EventList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiEventsV1beta1Event} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiEventsV1beta1EventList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiEventsV1beta1EventList - -const _property_types_IoK8sApiEventsV1beta1EventList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiEventsV1beta1Event}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiEventsV1beta1EventList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiEventsV1beta1EventList[name]))} - -function check_required(o::IoK8sApiEventsV1beta1EventList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiEventsV1beta1EventList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventSeries.jl b/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventSeries.jl deleted file mode 100644 index bc14e463..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiEventsV1beta1EventSeries.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.events.v1beta1.EventSeries -EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. - - IoK8sApiEventsV1beta1EventSeries(; - count=nothing, - lastObservedTime=nothing, - state=nothing, - ) - - - count::Int64 : Number of occurrences in this series up to the last heartbeat time - - lastObservedTime::ZonedDateTime : MicroTime is version of Time with microsecond level precision. - - state::String : Information whether this series is ongoing or finished. Deprecated. Planned removal for 1.18 -""" -Base.@kwdef mutable struct IoK8sApiEventsV1beta1EventSeries <: OpenAPI.APIModel - count::Union{Nothing, Int64} = nothing - lastObservedTime::Union{Nothing, ZonedDateTime} = nothing - state::Union{Nothing, String} = nothing - - function IoK8sApiEventsV1beta1EventSeries(count, lastObservedTime, state, ) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventSeries, Symbol("count"), count) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventSeries, Symbol("lastObservedTime"), lastObservedTime) - OpenAPI.validate_property(IoK8sApiEventsV1beta1EventSeries, Symbol("state"), state) - return new(count, lastObservedTime, state, ) - end -end # type IoK8sApiEventsV1beta1EventSeries - -const _property_types_IoK8sApiEventsV1beta1EventSeries = Dict{Symbol,String}(Symbol("count")=>"Int64", Symbol("lastObservedTime")=>"ZonedDateTime", Symbol("state")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiEventsV1beta1EventSeries }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiEventsV1beta1EventSeries[name]))} - -function check_required(o::IoK8sApiEventsV1beta1EventSeries) - o.count === nothing && (return false) - o.lastObservedTime === nothing && (return false) - o.state === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiEventsV1beta1EventSeries }, name::Symbol, val) - if name === Symbol("count") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1EventSeries", :format, val, "int32") - end - if name === Symbol("lastObservedTime") - OpenAPI.validate_param(name, "IoK8sApiEventsV1beta1EventSeries", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedCSIDriver.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedCSIDriver.jl deleted file mode 100644 index 029a0762..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedCSIDriver.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.AllowedCSIDriver -AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. - - IoK8sApiExtensionsV1beta1AllowedCSIDriver(; - name=nothing, - ) - - - name::String : Name is the registered name of the CSI driver -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1AllowedCSIDriver <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1AllowedCSIDriver(name, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1AllowedCSIDriver, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiExtensionsV1beta1AllowedCSIDriver - -const _property_types_IoK8sApiExtensionsV1beta1AllowedCSIDriver = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1AllowedCSIDriver }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1AllowedCSIDriver[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1AllowedCSIDriver) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1AllowedCSIDriver }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedFlexVolume.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedFlexVolume.jl deleted file mode 100644 index 1c20519d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedFlexVolume.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.AllowedFlexVolume -AllowedFlexVolume represents a single Flexvolume that is allowed to be used. Deprecated: use AllowedFlexVolume from policy API Group instead. - - IoK8sApiExtensionsV1beta1AllowedFlexVolume(; - driver=nothing, - ) - - - driver::String : driver is the name of the Flexvolume driver. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1AllowedFlexVolume <: OpenAPI.APIModel - driver::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1AllowedFlexVolume(driver, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1AllowedFlexVolume, Symbol("driver"), driver) - return new(driver, ) - end -end # type IoK8sApiExtensionsV1beta1AllowedFlexVolume - -const _property_types_IoK8sApiExtensionsV1beta1AllowedFlexVolume = Dict{Symbol,String}(Symbol("driver")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1AllowedFlexVolume }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1AllowedFlexVolume[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1AllowedFlexVolume) - o.driver === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1AllowedFlexVolume }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedHostPath.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedHostPath.jl deleted file mode 100644 index 685fd3e8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1AllowedHostPath.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.AllowedHostPath -AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. Deprecated: use AllowedHostPath from policy API Group instead. - - IoK8sApiExtensionsV1beta1AllowedHostPath(; - pathPrefix=nothing, - readOnly=nothing, - ) - - - pathPrefix::String : pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` - - readOnly::Bool : when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1AllowedHostPath <: OpenAPI.APIModel - pathPrefix::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiExtensionsV1beta1AllowedHostPath(pathPrefix, readOnly, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1AllowedHostPath, Symbol("pathPrefix"), pathPrefix) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1AllowedHostPath, Symbol("readOnly"), readOnly) - return new(pathPrefix, readOnly, ) - end -end # type IoK8sApiExtensionsV1beta1AllowedHostPath - -const _property_types_IoK8sApiExtensionsV1beta1AllowedHostPath = Dict{Symbol,String}(Symbol("pathPrefix")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1AllowedHostPath }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1AllowedHostPath[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1AllowedHostPath) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1AllowedHostPath }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSet.jl deleted file mode 100644 index d2ab26c0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSet -DEPRECATED - This group version of DaemonSet is deprecated by apps/v1beta2/DaemonSet. See the release notes for more information. DaemonSet represents the configuration of a daemon set. - - IoK8sApiExtensionsV1beta1DaemonSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1DaemonSetSpec - - status::IoK8sApiExtensionsV1beta1DaemonSetStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DaemonSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DaemonSetStatus } - - function IoK8sApiExtensionsV1beta1DaemonSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSet - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1DaemonSetSpec", Symbol("status")=>"IoK8sApiExtensionsV1beta1DaemonSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSet[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetCondition.jl deleted file mode 100644 index 0bec6485..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSetCondition -DaemonSetCondition describes the state of a DaemonSet at a certain point. - - IoK8sApiExtensionsV1beta1DaemonSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of DaemonSet condition. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1DaemonSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSetCondition - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetCondition[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetList.jl deleted file mode 100644 index 8566252b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSetList -DaemonSetList is a collection of daemon sets. - - IoK8sApiExtensionsV1beta1DaemonSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1DaemonSet} : A list of daemon sets. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1DaemonSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1DaemonSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSetList - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1DaemonSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetSpec.jl deleted file mode 100644 index b34506e5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetSpec.jl +++ /dev/null @@ -1,61 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSetSpec -DaemonSetSpec is the specification of a daemon set. - - IoK8sApiExtensionsV1beta1DaemonSetSpec(; - minReadySeconds=nothing, - revisionHistoryLimit=nothing, - selector=nothing, - template=nothing, - templateGeneration=nothing, - updateStrategy=nothing, - ) - - - minReadySeconds::Int64 : The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). - - revisionHistoryLimit::Int64 : The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec - - templateGeneration::Int64 : DEPRECATED. A sequence number representing a specific generation of the template. Populated by the system. It can be set only during the creation. - - updateStrategy::IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - templateGeneration::Union{Nothing, Int64} = nothing - updateStrategy = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy } - - function IoK8sApiExtensionsV1beta1DaemonSetSpec(minReadySeconds, revisionHistoryLimit, selector, template, templateGeneration, updateStrategy, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("template"), template) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("templateGeneration"), templateGeneration) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("updateStrategy"), updateStrategy) - return new(minReadySeconds, revisionHistoryLimit, selector, template, templateGeneration, updateStrategy, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSetSpec - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("templateGeneration")=>"Int64", Symbol("updateStrategy")=>"IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetSpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetSpec) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetSpec", :format, val, "int32") - end - if name === Symbol("templateGeneration") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetSpec", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetStatus.jl deleted file mode 100644 index 2cf53ebf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetStatus.jl +++ /dev/null @@ -1,98 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSetStatus -DaemonSetStatus represents the current status of a daemon set. - - IoK8sApiExtensionsV1beta1DaemonSetStatus(; - collisionCount=nothing, - conditions=nothing, - currentNumberScheduled=nothing, - desiredNumberScheduled=nothing, - numberAvailable=nothing, - numberMisscheduled=nothing, - numberReady=nothing, - numberUnavailable=nothing, - observedGeneration=nothing, - updatedNumberScheduled=nothing, - ) - - - collisionCount::Int64 : Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. - - conditions::Vector{IoK8sApiExtensionsV1beta1DaemonSetCondition} : Represents the latest available observations of a DaemonSet's current state. - - currentNumberScheduled::Int64 : The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - desiredNumberScheduled::Int64 : The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberAvailable::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) - - numberMisscheduled::Int64 : The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ - - numberReady::Int64 : The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. - - numberUnavailable::Int64 : The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) - - observedGeneration::Int64 : The most recent generation observed by the daemon set controller. - - updatedNumberScheduled::Int64 : The total number of nodes that are running updated daemon pod -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSetStatus <: OpenAPI.APIModel - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1DaemonSetCondition} } - currentNumberScheduled::Union{Nothing, Int64} = nothing - desiredNumberScheduled::Union{Nothing, Int64} = nothing - numberAvailable::Union{Nothing, Int64} = nothing - numberMisscheduled::Union{Nothing, Int64} = nothing - numberReady::Union{Nothing, Int64} = nothing - numberUnavailable::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - updatedNumberScheduled::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1DaemonSetStatus(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("currentNumberScheduled"), currentNumberScheduled) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("desiredNumberScheduled"), desiredNumberScheduled) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("numberAvailable"), numberAvailable) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("numberMisscheduled"), numberMisscheduled) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("numberReady"), numberReady) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("numberUnavailable"), numberUnavailable) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetStatus, Symbol("updatedNumberScheduled"), updatedNumberScheduled) - return new(collisionCount, conditions, currentNumberScheduled, desiredNumberScheduled, numberAvailable, numberMisscheduled, numberReady, numberUnavailable, observedGeneration, updatedNumberScheduled, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSetStatus - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSetStatus = Dict{Symbol,String}(Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiExtensionsV1beta1DaemonSetCondition}", Symbol("currentNumberScheduled")=>"Int64", Symbol("desiredNumberScheduled")=>"Int64", Symbol("numberAvailable")=>"Int64", Symbol("numberMisscheduled")=>"Int64", Symbol("numberReady")=>"Int64", Symbol("numberUnavailable")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("updatedNumberScheduled")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetStatus[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetStatus) - o.currentNumberScheduled === nothing && (return false) - o.desiredNumberScheduled === nothing && (return false) - o.numberMisscheduled === nothing && (return false) - o.numberReady === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetStatus }, name::Symbol, val) - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("currentNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("desiredNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberAvailable") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberMisscheduled") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberReady") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("numberUnavailable") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int64") - end - if name === Symbol("updatedNumberScheduled") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DaemonSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy.jl deleted file mode 100644 index c4315cf2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DaemonSetUpdateStrategy - - IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet - - type::String : Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is OnDelete. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet } - type::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy - -const _property_types_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Deployment.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Deployment.jl deleted file mode 100644 index 4d8eff07..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Deployment.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.Deployment -DEPRECATED - This group version of Deployment is deprecated by apps/v1beta2/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. - - IoK8sApiExtensionsV1beta1Deployment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1DeploymentSpec - - status::IoK8sApiExtensionsV1beta1DeploymentStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1Deployment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DeploymentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DeploymentStatus } - - function IoK8sApiExtensionsV1beta1Deployment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Deployment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Deployment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Deployment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Deployment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Deployment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiExtensionsV1beta1Deployment - -const _property_types_IoK8sApiExtensionsV1beta1Deployment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1DeploymentSpec", Symbol("status")=>"IoK8sApiExtensionsV1beta1DeploymentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1Deployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1Deployment[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1Deployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1Deployment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentCondition.jl deleted file mode 100644 index 45da6cc5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentCondition.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentCondition -DeploymentCondition describes the state of a deployment at a certain point. - - IoK8sApiExtensionsV1beta1DeploymentCondition(; - lastTransitionTime=nothing, - lastUpdateTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - lastUpdateTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of deployment condition. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - lastUpdateTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1DeploymentCondition(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("lastUpdateTime"), lastUpdateTime) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentCondition, Symbol("type"), type) - return new(lastTransitionTime, lastUpdateTime, message, reason, status, type, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentCondition - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("lastUpdateTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentCondition[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentCondition", :format, val, "date-time") - end - if name === Symbol("lastUpdateTime") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentList.jl deleted file mode 100644 index a73fcd19..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentList -DeploymentList is a list of Deployments. - - IoK8sApiExtensionsV1beta1DeploymentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1Deployment} : Items is the list of Deployments. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1Deployment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1DeploymentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentList - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1Deployment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentRollback.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentRollback.jl deleted file mode 100644 index 2ef2d62c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentRollback.jl +++ /dev/null @@ -1,49 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentRollback -DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. - - IoK8sApiExtensionsV1beta1DeploymentRollback(; - apiVersion=nothing, - kind=nothing, - name=nothing, - rollbackTo=nothing, - updatedAnnotations=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : Required: This must match the Name of a deployment. - - rollbackTo::IoK8sApiExtensionsV1beta1RollbackConfig - - updatedAnnotations::Dict{String, String} : The annotations to be updated to a deployment -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentRollback <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - rollbackTo = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RollbackConfig } - updatedAnnotations::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiExtensionsV1beta1DeploymentRollback(apiVersion, kind, name, rollbackTo, updatedAnnotations, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentRollback, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentRollback, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentRollback, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentRollback, Symbol("rollbackTo"), rollbackTo) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentRollback, Symbol("updatedAnnotations"), updatedAnnotations) - return new(apiVersion, kind, name, rollbackTo, updatedAnnotations, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentRollback - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentRollback = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("rollbackTo")=>"IoK8sApiExtensionsV1beta1RollbackConfig", Symbol("updatedAnnotations")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentRollback }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentRollback[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentRollback) - o.name === nothing && (return false) - o.rollbackTo === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentRollback }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentSpec.jl deleted file mode 100644 index a67881a8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentSpec.jl +++ /dev/null @@ -1,76 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentSpec -DeploymentSpec is the specification of the desired behavior of the Deployment. - - IoK8sApiExtensionsV1beta1DeploymentSpec(; - minReadySeconds=nothing, - paused=nothing, - progressDeadlineSeconds=nothing, - replicas=nothing, - revisionHistoryLimit=nothing, - rollbackTo=nothing, - selector=nothing, - strategy=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - paused::Bool : Indicates that the deployment is paused and will not be processed by the deployment controller. - - progressDeadlineSeconds::Int64 : The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. This is set to the max value of int32 (i.e. 2147483647) by default, which means \"no deadline\". - - replicas::Int64 : Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. - - revisionHistoryLimit::Int64 : The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. This is set to the max value of int32 (i.e. 2147483647) by default, which means \"retaining all old RelicaSets\". - - rollbackTo::IoK8sApiExtensionsV1beta1RollbackConfig - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - strategy::IoK8sApiExtensionsV1beta1DeploymentStrategy - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - paused::Union{Nothing, Bool} = nothing - progressDeadlineSeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - revisionHistoryLimit::Union{Nothing, Int64} = nothing - rollbackTo = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RollbackConfig } - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - strategy = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DeploymentStrategy } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiExtensionsV1beta1DeploymentSpec(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, rollbackTo, selector, strategy, template, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("paused"), paused) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("progressDeadlineSeconds"), progressDeadlineSeconds) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("rollbackTo"), rollbackTo) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentSpec, Symbol("template"), template) - return new(minReadySeconds, paused, progressDeadlineSeconds, replicas, revisionHistoryLimit, rollbackTo, selector, strategy, template, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentSpec - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("paused")=>"Bool", Symbol("progressDeadlineSeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("revisionHistoryLimit")=>"Int64", Symbol("rollbackTo")=>"IoK8sApiExtensionsV1beta1RollbackConfig", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("strategy")=>"IoK8sApiExtensionsV1beta1DeploymentStrategy", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentSpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentSpec) - o.template === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("progressDeadlineSeconds") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentSpec", :format, val, "int32") - end - if name === Symbol("revisionHistoryLimit") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStatus.jl deleted file mode 100644 index a59a4148..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStatus.jl +++ /dev/null @@ -1,80 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentStatus -DeploymentStatus is the most recently observed status of the Deployment. - - IoK8sApiExtensionsV1beta1DeploymentStatus(; - availableReplicas=nothing, - collisionCount=nothing, - conditions=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - unavailableReplicas=nothing, - updatedReplicas=nothing, - ) - - - availableReplicas::Int64 : Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. - - collisionCount::Int64 : Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. - - conditions::Vector{IoK8sApiExtensionsV1beta1DeploymentCondition} : Represents the latest available observations of a deployment's current state. - - observedGeneration::Int64 : The generation observed by the deployment controller. - - readyReplicas::Int64 : Total number of ready pods targeted by this deployment. - - replicas::Int64 : Total number of non-terminated pods targeted by this deployment (their labels match the selector). - - unavailableReplicas::Int64 : Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. - - updatedReplicas::Int64 : Total number of non-terminated pods targeted by this deployment that have the desired template spec. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - collisionCount::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1DeploymentCondition} } - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - unavailableReplicas::Union{Nothing, Int64} = nothing - updatedReplicas::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1DeploymentStatus(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("collisionCount"), collisionCount) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("unavailableReplicas"), unavailableReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStatus, Symbol("updatedReplicas"), updatedReplicas) - return new(availableReplicas, collisionCount, conditions, observedGeneration, readyReplicas, replicas, unavailableReplicas, updatedReplicas, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentStatus - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("collisionCount")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiExtensionsV1beta1DeploymentCondition}", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", Symbol("unavailableReplicas")=>"Int64", Symbol("updatedReplicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentStatus[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("collisionCount") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("unavailableReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end - if name === Symbol("updatedReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1DeploymentStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStrategy.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStrategy.jl deleted file mode 100644 index 1a3c1dff..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1DeploymentStrategy.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.DeploymentStrategy -DeploymentStrategy describes how to replace existing pods with new ones. - - IoK8sApiExtensionsV1beta1DeploymentStrategy(; - rollingUpdate=nothing, - type=nothing, - ) - - - rollingUpdate::IoK8sApiExtensionsV1beta1RollingUpdateDeployment - - type::String : Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1DeploymentStrategy <: OpenAPI.APIModel - rollingUpdate = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RollingUpdateDeployment } - type::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1DeploymentStrategy(rollingUpdate, type, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStrategy, Symbol("rollingUpdate"), rollingUpdate) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1DeploymentStrategy, Symbol("type"), type) - return new(rollingUpdate, type, ) - end -end # type IoK8sApiExtensionsV1beta1DeploymentStrategy - -const _property_types_IoK8sApiExtensionsV1beta1DeploymentStrategy = Dict{Symbol,String}(Symbol("rollingUpdate")=>"IoK8sApiExtensionsV1beta1RollingUpdateDeployment", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1DeploymentStrategy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DeploymentStrategy[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1DeploymentStrategy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1DeploymentStrategy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions.jl deleted file mode 100644 index 84d1e0bf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.FSGroupStrategyOptions -FSGroupStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use FSGroupStrategyOptions from policy API Group instead. - - IoK8sApiExtensionsV1beta1FSGroupStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiExtensionsV1beta1IDRange} : ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate what FSGroup is used in the SecurityContext. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1FSGroupStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1FSGroupStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1FSGroupStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1FSGroupStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiExtensionsV1beta1FSGroupStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiExtensionsV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1FSGroupStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1FSGroupStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1FSGroupStrategyOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1FSGroupStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressPath.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressPath.jl deleted file mode 100644 index 009e9f2c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressPath.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.HTTPIngressPath -HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. - - IoK8sApiExtensionsV1beta1HTTPIngressPath(; - backend=nothing, - path=nothing, - ) - - - backend::IoK8sApiExtensionsV1beta1IngressBackend - - path::String : Path is an extended POSIX regex as defined by IEEE Std 1003.1, (i.e this follows the egrep/unix syntax, not the perl syntax) matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a '/'. If unspecified, the path defaults to a catch all sending traffic to the backend. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1HTTPIngressPath <: OpenAPI.APIModel - backend = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1IngressBackend } - path::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1HTTPIngressPath(backend, path, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1HTTPIngressPath, Symbol("backend"), backend) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1HTTPIngressPath, Symbol("path"), path) - return new(backend, path, ) - end -end # type IoK8sApiExtensionsV1beta1HTTPIngressPath - -const _property_types_IoK8sApiExtensionsV1beta1HTTPIngressPath = Dict{Symbol,String}(Symbol("backend")=>"IoK8sApiExtensionsV1beta1IngressBackend", Symbol("path")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1HTTPIngressPath }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1HTTPIngressPath[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1HTTPIngressPath) - o.backend === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1HTTPIngressPath }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue.jl deleted file mode 100644 index a0c68cd6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.HTTPIngressRuleValue -HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http://<host>/<path>?<searchpart> -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. - - IoK8sApiExtensionsV1beta1HTTPIngressRuleValue(; - paths=nothing, - ) - - - paths::Vector{IoK8sApiExtensionsV1beta1HTTPIngressPath} : A collection of paths that map requests to backends. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1HTTPIngressRuleValue <: OpenAPI.APIModel - paths::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1HTTPIngressPath} } - - function IoK8sApiExtensionsV1beta1HTTPIngressRuleValue(paths, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1HTTPIngressRuleValue, Symbol("paths"), paths) - return new(paths, ) - end -end # type IoK8sApiExtensionsV1beta1HTTPIngressRuleValue - -const _property_types_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue = Dict{Symbol,String}(Symbol("paths")=>"Vector{IoK8sApiExtensionsV1beta1HTTPIngressPath}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1HTTPIngressRuleValue }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1HTTPIngressRuleValue[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1HTTPIngressRuleValue) - o.paths === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1HTTPIngressRuleValue }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HostPortRange.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HostPortRange.jl deleted file mode 100644 index b41a6ca4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1HostPortRange.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.HostPortRange -HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. Deprecated: use HostPortRange from policy API Group instead. - - IoK8sApiExtensionsV1beta1HostPortRange(; - max=nothing, - min=nothing, - ) - - - max::Int64 : max is the end of the range, inclusive. - - min::Int64 : min is the start of the range, inclusive. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1HostPortRange <: OpenAPI.APIModel - max::Union{Nothing, Int64} = nothing - min::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1HostPortRange(max, min, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1HostPortRange, Symbol("max"), max) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1HostPortRange, Symbol("min"), min) - return new(max, min, ) - end -end # type IoK8sApiExtensionsV1beta1HostPortRange - -const _property_types_IoK8sApiExtensionsV1beta1HostPortRange = Dict{Symbol,String}(Symbol("max")=>"Int64", Symbol("min")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1HostPortRange }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1HostPortRange[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1HostPortRange) - o.max === nothing && (return false) - o.min === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1HostPortRange }, name::Symbol, val) - if name === Symbol("max") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1HostPortRange", :format, val, "int32") - end - if name === Symbol("min") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1HostPortRange", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IDRange.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IDRange.jl deleted file mode 100644 index 795916fa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IDRange.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IDRange -IDRange provides a min/max of an allowed range of IDs. Deprecated: use IDRange from policy API Group instead. - - IoK8sApiExtensionsV1beta1IDRange(; - max=nothing, - min=nothing, - ) - - - max::Int64 : max is the end of the range, inclusive. - - min::Int64 : min is the start of the range, inclusive. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IDRange <: OpenAPI.APIModel - max::Union{Nothing, Int64} = nothing - min::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1IDRange(max, min, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IDRange, Symbol("max"), max) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IDRange, Symbol("min"), min) - return new(max, min, ) - end -end # type IoK8sApiExtensionsV1beta1IDRange - -const _property_types_IoK8sApiExtensionsV1beta1IDRange = Dict{Symbol,String}(Symbol("max")=>"Int64", Symbol("min")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IDRange }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IDRange[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IDRange) - o.max === nothing && (return false) - o.min === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IDRange }, name::Symbol, val) - if name === Symbol("max") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1IDRange", :format, val, "int64") - end - if name === Symbol("min") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1IDRange", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IPBlock.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IPBlock.jl deleted file mode 100644 index 786c3cad..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IPBlock.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IPBlock -DEPRECATED 1.9 - This group version of IPBlock is deprecated by networking/v1/IPBlock. IPBlock describes a particular CIDR (Ex. \"192.168.1.1/24\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. - - IoK8sApiExtensionsV1beta1IPBlock(; - cidr=nothing, - except=nothing, - ) - - - cidr::String : CIDR is a string representing the IP Block Valid examples are \"192.168.1.1/24\" - - except::Vector{String} : Except is a slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" Except values will be rejected if they are outside the CIDR range -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IPBlock <: OpenAPI.APIModel - cidr::Union{Nothing, String} = nothing - except::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiExtensionsV1beta1IPBlock(cidr, except, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IPBlock, Symbol("cidr"), cidr) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IPBlock, Symbol("except"), except) - return new(cidr, except, ) - end -end # type IoK8sApiExtensionsV1beta1IPBlock - -const _property_types_IoK8sApiExtensionsV1beta1IPBlock = Dict{Symbol,String}(Symbol("cidr")=>"String", Symbol("except")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IPBlock }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IPBlock[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IPBlock) - o.cidr === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IPBlock }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Ingress.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Ingress.jl deleted file mode 100644 index ad9b9b22..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Ingress.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.Ingress -Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. DEPRECATED - This group version of Ingress is deprecated by networking.k8s.io/v1beta1 Ingress. See the release notes for more information. - - IoK8sApiExtensionsV1beta1Ingress(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1IngressSpec - - status::IoK8sApiExtensionsV1beta1IngressStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1Ingress <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1IngressSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1IngressStatus } - - function IoK8sApiExtensionsV1beta1Ingress(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Ingress, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Ingress, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Ingress, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Ingress, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Ingress, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiExtensionsV1beta1Ingress - -const _property_types_IoK8sApiExtensionsV1beta1Ingress = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1IngressSpec", Symbol("status")=>"IoK8sApiExtensionsV1beta1IngressStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1Ingress }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1Ingress[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1Ingress) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1Ingress }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressBackend.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressBackend.jl deleted file mode 100644 index 884f40a6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressBackend.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressBackend -IngressBackend describes all endpoints for a given service and port. - - IoK8sApiExtensionsV1beta1IngressBackend(; - serviceName=nothing, - servicePort=nothing, - ) - - - serviceName::String : Specifies the name of the referenced service. - - servicePort::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressBackend <: OpenAPI.APIModel - serviceName::Union{Nothing, String} = nothing - servicePort::Union{Nothing, Any} = nothing - - function IoK8sApiExtensionsV1beta1IngressBackend(serviceName, servicePort, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressBackend, Symbol("serviceName"), serviceName) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressBackend, Symbol("servicePort"), servicePort) - return new(serviceName, servicePort, ) - end -end # type IoK8sApiExtensionsV1beta1IngressBackend - -const _property_types_IoK8sApiExtensionsV1beta1IngressBackend = Dict{Symbol,String}(Symbol("serviceName")=>"String", Symbol("servicePort")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressBackend }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressBackend[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressBackend) - o.serviceName === nothing && (return false) - o.servicePort === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressBackend }, name::Symbol, val) - if name === Symbol("servicePort") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1IngressBackend", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressList.jl deleted file mode 100644 index 014eec45..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressList -IngressList is a collection of Ingress. - - IoK8sApiExtensionsV1beta1IngressList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1Ingress} : Items is the list of Ingress. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1Ingress} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1IngressList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1IngressList - -const _property_types_IoK8sApiExtensionsV1beta1IngressList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1Ingress}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressRule.jl deleted file mode 100644 index 12efce2a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressRule -IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. - - IoK8sApiExtensionsV1beta1IngressRule(; - host=nothing, - http=nothing, - ) - - - host::String : Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the IP in the Spec of the parent Ingress. 2. The `:` delimiter is not respected because ports are not allowed. Currently the port of an Ingress is implicitly :80 for http and :443 for https. Both these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue. - - http::IoK8sApiExtensionsV1beta1HTTPIngressRuleValue -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressRule <: OpenAPI.APIModel - host::Union{Nothing, String} = nothing - http = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1HTTPIngressRuleValue } - - function IoK8sApiExtensionsV1beta1IngressRule(host, http, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressRule, Symbol("host"), host) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressRule, Symbol("http"), http) - return new(host, http, ) - end -end # type IoK8sApiExtensionsV1beta1IngressRule - -const _property_types_IoK8sApiExtensionsV1beta1IngressRule = Dict{Symbol,String}(Symbol("host")=>"String", Symbol("http")=>"IoK8sApiExtensionsV1beta1HTTPIngressRuleValue", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressRule[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressSpec.jl deleted file mode 100644 index 1bae7f5d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressSpec.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressSpec -IngressSpec describes the Ingress the user wishes to exist. - - IoK8sApiExtensionsV1beta1IngressSpec(; - backend=nothing, - rules=nothing, - tls=nothing, - ) - - - backend::IoK8sApiExtensionsV1beta1IngressBackend - - rules::Vector{IoK8sApiExtensionsV1beta1IngressRule} : A list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend. - - tls::Vector{IoK8sApiExtensionsV1beta1IngressTLS} : TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressSpec <: OpenAPI.APIModel - backend = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1IngressBackend } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IngressRule} } - tls::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IngressTLS} } - - function IoK8sApiExtensionsV1beta1IngressSpec(backend, rules, tls, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressSpec, Symbol("backend"), backend) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressSpec, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressSpec, Symbol("tls"), tls) - return new(backend, rules, tls, ) - end -end # type IoK8sApiExtensionsV1beta1IngressSpec - -const _property_types_IoK8sApiExtensionsV1beta1IngressSpec = Dict{Symbol,String}(Symbol("backend")=>"IoK8sApiExtensionsV1beta1IngressBackend", Symbol("rules")=>"Vector{IoK8sApiExtensionsV1beta1IngressRule}", Symbol("tls")=>"Vector{IoK8sApiExtensionsV1beta1IngressTLS}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressSpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressStatus.jl deleted file mode 100644 index 46cebf25..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressStatus -IngressStatus describe the current state of the Ingress. - - IoK8sApiExtensionsV1beta1IngressStatus(; - loadBalancer=nothing, - ) - - - loadBalancer::IoK8sApiCoreV1LoadBalancerStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressStatus <: OpenAPI.APIModel - loadBalancer = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LoadBalancerStatus } - - function IoK8sApiExtensionsV1beta1IngressStatus(loadBalancer, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressStatus, Symbol("loadBalancer"), loadBalancer) - return new(loadBalancer, ) - end -end # type IoK8sApiExtensionsV1beta1IngressStatus - -const _property_types_IoK8sApiExtensionsV1beta1IngressStatus = Dict{Symbol,String}(Symbol("loadBalancer")=>"IoK8sApiCoreV1LoadBalancerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressStatus[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressTLS.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressTLS.jl deleted file mode 100644 index 13843603..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1IngressTLS.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.IngressTLS -IngressTLS describes the transport layer security associated with an Ingress. - - IoK8sApiExtensionsV1beta1IngressTLS(; - hosts=nothing, - secretName=nothing, - ) - - - hosts::Vector{String} : Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. - - secretName::String : SecretName is the name of the secret used to terminate SSL traffic on 443. Field is left optional to allow SSL routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the Host header is used for routing. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1IngressTLS <: OpenAPI.APIModel - hosts::Union{Nothing, Vector{String}} = nothing - secretName::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1IngressTLS(hosts, secretName, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressTLS, Symbol("hosts"), hosts) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1IngressTLS, Symbol("secretName"), secretName) - return new(hosts, secretName, ) - end -end # type IoK8sApiExtensionsV1beta1IngressTLS - -const _property_types_IoK8sApiExtensionsV1beta1IngressTLS = Dict{Symbol,String}(Symbol("hosts")=>"Vector{String}", Symbol("secretName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1IngressTLS }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1IngressTLS[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1IngressTLS) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1IngressTLS }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicy.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicy.jl deleted file mode 100644 index c81bd889..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicy.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicy -DEPRECATED 1.9 - This group version of NetworkPolicy is deprecated by networking/v1/NetworkPolicy. NetworkPolicy describes what network traffic is allowed for a set of Pods - - IoK8sApiExtensionsV1beta1NetworkPolicy(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1NetworkPolicySpec -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicy <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1NetworkPolicySpec } - - function IoK8sApiExtensionsV1beta1NetworkPolicy(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicy, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicy, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicy, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicy, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicy - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicy = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1NetworkPolicySpec", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicy[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule.jl deleted file mode 100644 index aacee3ca..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicyEgressRule -DEPRECATED 1.9 - This group version of NetworkPolicyEgressRule is deprecated by networking/v1/NetworkPolicyEgressRule. NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 - - IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule(; - ports=nothing, - to=nothing, - ) - - - ports::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort} : List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. - - to::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer} : List of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule <: OpenAPI.APIModel - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort} } - to::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer} } - - function IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule(ports, to, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule, Symbol("ports"), ports) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule, Symbol("to"), to) - return new(ports, to, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule = Dict{Symbol,String}(Symbol("ports")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort}", Symbol("to")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule.jl deleted file mode 100644 index c6bd11fb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicyIngressRule -DEPRECATED 1.9 - This group version of NetworkPolicyIngressRule is deprecated by networking/v1/NetworkPolicyIngressRule. This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from. - - IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule(; - from=nothing, - ports=nothing, - ) - - - from::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer} : List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. - - ports::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort} : List of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule <: OpenAPI.APIModel - from::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer} } - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort} } - - function IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule(from, ports, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule, Symbol("from"), from) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule, Symbol("ports"), ports) - return new(from, ports, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule = Dict{Symbol,String}(Symbol("from")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPeer}", Symbol("ports")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyPort}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyList.jl deleted file mode 100644 index 9b8b2cca..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicyList -DEPRECATED 1.9 - This group version of NetworkPolicyList is deprecated by networking/v1/NetworkPolicyList. Network Policy List is a list of NetworkPolicy objects. - - IoK8sApiExtensionsV1beta1NetworkPolicyList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1NetworkPolicy} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicyList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicy} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1NetworkPolicyList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicyList - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicyList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicy}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicyList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicyList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPeer.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPeer.jl deleted file mode 100644 index 337c4678..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPeer.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicyPeer -DEPRECATED 1.9 - This group version of NetworkPolicyPeer is deprecated by networking/v1/NetworkPolicyPeer. - - IoK8sApiExtensionsV1beta1NetworkPolicyPeer(; - ipBlock=nothing, - namespaceSelector=nothing, - podSelector=nothing, - ) - - - ipBlock::IoK8sApiExtensionsV1beta1IPBlock - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - podSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicyPeer <: OpenAPI.APIModel - ipBlock = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1IPBlock } - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - podSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiExtensionsV1beta1NetworkPolicyPeer(ipBlock, namespaceSelector, podSelector, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyPeer, Symbol("ipBlock"), ipBlock) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyPeer, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyPeer, Symbol("podSelector"), podSelector) - return new(ipBlock, namespaceSelector, podSelector, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicyPeer - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicyPeer = Dict{Symbol,String}(Symbol("ipBlock")=>"IoK8sApiExtensionsV1beta1IPBlock", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("podSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyPeer }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicyPeer[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicyPeer) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyPeer }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPort.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPort.jl deleted file mode 100644 index b738ef9c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicyPort.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicyPort -DEPRECATED 1.9 - This group version of NetworkPolicyPort is deprecated by networking/v1/NetworkPolicyPort. - - IoK8sApiExtensionsV1beta1NetworkPolicyPort(; - port=nothing, - protocol=nothing, - ) - - - port::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - protocol::String : Optional. The protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicyPort <: OpenAPI.APIModel - port::Union{Nothing, Any} = nothing - protocol::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1NetworkPolicyPort(port, protocol, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyPort, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicyPort, Symbol("protocol"), protocol) - return new(port, protocol, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicyPort - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicyPort = Dict{Symbol,String}(Symbol("port")=>"Any", Symbol("protocol")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyPort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicyPort[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicyPort) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicyPort }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1NetworkPolicyPort", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicySpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicySpec.jl deleted file mode 100644 index c224d9ce..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1NetworkPolicySpec.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.NetworkPolicySpec -DEPRECATED 1.9 - This group version of NetworkPolicySpec is deprecated by networking/v1/NetworkPolicySpec. - - IoK8sApiExtensionsV1beta1NetworkPolicySpec(; - egress=nothing, - ingress=nothing, - podSelector=nothing, - policyTypes=nothing, - ) - - - egress::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule} : List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 - - ingress::Vector{IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule} : List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default). - - podSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - policyTypes::Vector{String} : List of rule types that the NetworkPolicy relates to. Valid options are \"Ingress\", \"Egress\", or \"Ingress,Egress\". If this field is not specified, it will default based on the existence of Ingress or Egress rules; policies that contain an Egress section are assumed to affect Egress, and all policies (whether or not they contain an Ingress section) are assumed to affect Ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an Egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8 -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1NetworkPolicySpec <: OpenAPI.APIModel - egress::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule} } - ingress::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule} } - podSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - policyTypes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiExtensionsV1beta1NetworkPolicySpec(egress, ingress, podSelector, policyTypes, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicySpec, Symbol("egress"), egress) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicySpec, Symbol("ingress"), ingress) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicySpec, Symbol("podSelector"), podSelector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1NetworkPolicySpec, Symbol("policyTypes"), policyTypes) - return new(egress, ingress, podSelector, policyTypes, ) - end -end # type IoK8sApiExtensionsV1beta1NetworkPolicySpec - -const _property_types_IoK8sApiExtensionsV1beta1NetworkPolicySpec = Dict{Symbol,String}(Symbol("egress")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule}", Symbol("ingress")=>"Vector{IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule}", Symbol("podSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("policyTypes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicySpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1NetworkPolicySpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1NetworkPolicySpec) - o.podSelector === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1NetworkPolicySpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicy.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicy.jl deleted file mode 100644 index f8613599..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicy.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.PodSecurityPolicy -PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated: use PodSecurityPolicy from policy API Group instead. - - IoK8sApiExtensionsV1beta1PodSecurityPolicy(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1PodSecurityPolicySpec -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1PodSecurityPolicy <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1PodSecurityPolicySpec } - - function IoK8sApiExtensionsV1beta1PodSecurityPolicy(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicy, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicy, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicy, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicy, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiExtensionsV1beta1PodSecurityPolicy - -const _property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicy = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1PodSecurityPolicySpec", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicy[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1PodSecurityPolicy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicyList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicyList.jl deleted file mode 100644 index 2f1d2638..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicyList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.PodSecurityPolicyList -PodSecurityPolicyList is a list of PodSecurityPolicy objects. Deprecated: use PodSecurityPolicyList from policy API Group instead. - - IoK8sApiExtensionsV1beta1PodSecurityPolicyList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1PodSecurityPolicy} : items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1PodSecurityPolicyList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1PodSecurityPolicy} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1PodSecurityPolicyList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicyList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicyList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicyList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicyList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1PodSecurityPolicyList - -const _property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicyList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1PodSecurityPolicy}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicyList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicyList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1PodSecurityPolicyList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicyList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec.jl deleted file mode 100644 index e4a841bb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec.jl +++ /dev/null @@ -1,127 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.PodSecurityPolicySpec -PodSecurityPolicySpec defines the policy enforced. Deprecated: use PodSecurityPolicySpec from policy API Group instead. - - IoK8sApiExtensionsV1beta1PodSecurityPolicySpec(; - allowPrivilegeEscalation=nothing, - allowedCSIDrivers=nothing, - allowedCapabilities=nothing, - allowedFlexVolumes=nothing, - allowedHostPaths=nothing, - allowedProcMountTypes=nothing, - allowedUnsafeSysctls=nothing, - defaultAddCapabilities=nothing, - defaultAllowPrivilegeEscalation=nothing, - forbiddenSysctls=nothing, - fsGroup=nothing, - hostIPC=nothing, - hostNetwork=nothing, - hostPID=nothing, - hostPorts=nothing, - privileged=nothing, - readOnlyRootFilesystem=nothing, - requiredDropCapabilities=nothing, - runAsGroup=nothing, - runAsUser=nothing, - runtimeClass=nothing, - seLinux=nothing, - supplementalGroups=nothing, - volumes=nothing, - ) - - - allowPrivilegeEscalation::Bool : allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. - - allowedCSIDrivers::Vector{IoK8sApiExtensionsV1beta1AllowedCSIDriver} : AllowedCSIDrivers is a whitelist of inline CSI drivers that must be explicitly set to be embedded within a pod spec. An empty value indicates that any CSI driver can be used for inline ephemeral volumes. - - allowedCapabilities::Vector{String} : allowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field may be added at the pod author's discretion. You must not list a capability in both allowedCapabilities and requiredDropCapabilities. - - allowedFlexVolumes::Vector{IoK8sApiExtensionsV1beta1AllowedFlexVolume} : allowedFlexVolumes is a whitelist of allowed Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the \"volumes\" field. - - allowedHostPaths::Vector{IoK8sApiExtensionsV1beta1AllowedHostPath} : allowedHostPaths is a white list of allowed host paths. Empty indicates that all host paths may be used. - - allowedProcMountTypes::Vector{String} : AllowedProcMountTypes is a whitelist of allowed ProcMountTypes. Empty or nil indicates that only the DefaultProcMountType may be used. This requires the ProcMountType feature flag to be enabled. - - allowedUnsafeSysctls::Vector{String} : allowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection. Examples: e.g. \"foo/*\" allows \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" allows \"foo.bar\", \"foo.baz\", etc. - - defaultAddCapabilities::Vector{String} : defaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capability in both defaultAddCapabilities and requiredDropCapabilities. Capabilities added here are implicitly allowed, and need not be included in the allowedCapabilities list. - - defaultAllowPrivilegeEscalation::Bool : defaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. - - forbiddenSysctls::Vector{String} : forbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. Examples: e.g. \"foo/*\" forbids \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" forbids \"foo.bar\", \"foo.baz\", etc. - - fsGroup::IoK8sApiExtensionsV1beta1FSGroupStrategyOptions - - hostIPC::Bool : hostIPC determines if the policy allows the use of HostIPC in the pod spec. - - hostNetwork::Bool : hostNetwork determines if the policy allows the use of HostNetwork in the pod spec. - - hostPID::Bool : hostPID determines if the policy allows the use of HostPID in the pod spec. - - hostPorts::Vector{IoK8sApiExtensionsV1beta1HostPortRange} : hostPorts determines which host port ranges are allowed to be exposed. - - privileged::Bool : privileged determines if a pod can request to be run as privileged. - - readOnlyRootFilesystem::Bool : readOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the PSP should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. - - requiredDropCapabilities::Vector{String} : requiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. - - runAsGroup::IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions - - runAsUser::IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions - - runtimeClass::IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions - - seLinux::IoK8sApiExtensionsV1beta1SELinuxStrategyOptions - - supplementalGroups::IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions - - volumes::Vector{String} : volumes is a white list of allowed volume plugins. Empty indicates that no volumes may be used. To allow all volumes you may use '*'. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1PodSecurityPolicySpec <: OpenAPI.APIModel - allowPrivilegeEscalation::Union{Nothing, Bool} = nothing - allowedCSIDrivers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1AllowedCSIDriver} } - allowedCapabilities::Union{Nothing, Vector{String}} = nothing - allowedFlexVolumes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1AllowedFlexVolume} } - allowedHostPaths::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1AllowedHostPath} } - allowedProcMountTypes::Union{Nothing, Vector{String}} = nothing - allowedUnsafeSysctls::Union{Nothing, Vector{String}} = nothing - defaultAddCapabilities::Union{Nothing, Vector{String}} = nothing - defaultAllowPrivilegeEscalation::Union{Nothing, Bool} = nothing - forbiddenSysctls::Union{Nothing, Vector{String}} = nothing - fsGroup = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1FSGroupStrategyOptions } - hostIPC::Union{Nothing, Bool} = nothing - hostNetwork::Union{Nothing, Bool} = nothing - hostPID::Union{Nothing, Bool} = nothing - hostPorts::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1HostPortRange} } - privileged::Union{Nothing, Bool} = nothing - readOnlyRootFilesystem::Union{Nothing, Bool} = nothing - requiredDropCapabilities::Union{Nothing, Vector{String}} = nothing - runAsGroup = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions } - runAsUser = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions } - runtimeClass = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions } - seLinux = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1SELinuxStrategyOptions } - supplementalGroups = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions } - volumes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiExtensionsV1beta1PodSecurityPolicySpec(allowPrivilegeEscalation, allowedCSIDrivers, allowedCapabilities, allowedFlexVolumes, allowedHostPaths, allowedProcMountTypes, allowedUnsafeSysctls, defaultAddCapabilities, defaultAllowPrivilegeEscalation, forbiddenSysctls, fsGroup, hostIPC, hostNetwork, hostPID, hostPorts, privileged, readOnlyRootFilesystem, requiredDropCapabilities, runAsGroup, runAsUser, runtimeClass, seLinux, supplementalGroups, volumes, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowPrivilegeEscalation"), allowPrivilegeEscalation) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedCSIDrivers"), allowedCSIDrivers) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedCapabilities"), allowedCapabilities) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedFlexVolumes"), allowedFlexVolumes) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedHostPaths"), allowedHostPaths) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedProcMountTypes"), allowedProcMountTypes) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("allowedUnsafeSysctls"), allowedUnsafeSysctls) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("defaultAddCapabilities"), defaultAddCapabilities) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("defaultAllowPrivilegeEscalation"), defaultAllowPrivilegeEscalation) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("forbiddenSysctls"), forbiddenSysctls) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("fsGroup"), fsGroup) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("hostIPC"), hostIPC) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("hostNetwork"), hostNetwork) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("hostPID"), hostPID) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("hostPorts"), hostPorts) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("privileged"), privileged) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("readOnlyRootFilesystem"), readOnlyRootFilesystem) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("requiredDropCapabilities"), requiredDropCapabilities) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("runAsGroup"), runAsGroup) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("runAsUser"), runAsUser) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("runtimeClass"), runtimeClass) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("seLinux"), seLinux) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("supplementalGroups"), supplementalGroups) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1PodSecurityPolicySpec, Symbol("volumes"), volumes) - return new(allowPrivilegeEscalation, allowedCSIDrivers, allowedCapabilities, allowedFlexVolumes, allowedHostPaths, allowedProcMountTypes, allowedUnsafeSysctls, defaultAddCapabilities, defaultAllowPrivilegeEscalation, forbiddenSysctls, fsGroup, hostIPC, hostNetwork, hostPID, hostPorts, privileged, readOnlyRootFilesystem, requiredDropCapabilities, runAsGroup, runAsUser, runtimeClass, seLinux, supplementalGroups, volumes, ) - end -end # type IoK8sApiExtensionsV1beta1PodSecurityPolicySpec - -const _property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec = Dict{Symbol,String}(Symbol("allowPrivilegeEscalation")=>"Bool", Symbol("allowedCSIDrivers")=>"Vector{IoK8sApiExtensionsV1beta1AllowedCSIDriver}", Symbol("allowedCapabilities")=>"Vector{String}", Symbol("allowedFlexVolumes")=>"Vector{IoK8sApiExtensionsV1beta1AllowedFlexVolume}", Symbol("allowedHostPaths")=>"Vector{IoK8sApiExtensionsV1beta1AllowedHostPath}", Symbol("allowedProcMountTypes")=>"Vector{String}", Symbol("allowedUnsafeSysctls")=>"Vector{String}", Symbol("defaultAddCapabilities")=>"Vector{String}", Symbol("defaultAllowPrivilegeEscalation")=>"Bool", Symbol("forbiddenSysctls")=>"Vector{String}", Symbol("fsGroup")=>"IoK8sApiExtensionsV1beta1FSGroupStrategyOptions", Symbol("hostIPC")=>"Bool", Symbol("hostNetwork")=>"Bool", Symbol("hostPID")=>"Bool", Symbol("hostPorts")=>"Vector{IoK8sApiExtensionsV1beta1HostPortRange}", Symbol("privileged")=>"Bool", Symbol("readOnlyRootFilesystem")=>"Bool", Symbol("requiredDropCapabilities")=>"Vector{String}", Symbol("runAsGroup")=>"IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions", Symbol("runAsUser")=>"IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions", Symbol("runtimeClass")=>"IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions", Symbol("seLinux")=>"IoK8sApiExtensionsV1beta1SELinuxStrategyOptions", Symbol("supplementalGroups")=>"IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions", Symbol("volumes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicySpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1PodSecurityPolicySpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1PodSecurityPolicySpec) - o.fsGroup === nothing && (return false) - o.runAsUser === nothing && (return false) - o.seLinux === nothing && (return false) - o.supplementalGroups === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1PodSecurityPolicySpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSet.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSet.jl deleted file mode 100644 index d591502a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSet.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ReplicaSet -DEPRECATED - This group version of ReplicaSet is deprecated by apps/v1beta2/ReplicaSet. See the release notes for more information. ReplicaSet ensures that a specified number of pod replicas are running at any given time. - - IoK8sApiExtensionsV1beta1ReplicaSet(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1ReplicaSetSpec - - status::IoK8sApiExtensionsV1beta1ReplicaSetStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ReplicaSet <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1ReplicaSetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1ReplicaSetStatus } - - function IoK8sApiExtensionsV1beta1ReplicaSet(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSet, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSet, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSet, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSet, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSet, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiExtensionsV1beta1ReplicaSet - -const _property_types_IoK8sApiExtensionsV1beta1ReplicaSet = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1ReplicaSetSpec", Symbol("status")=>"IoK8sApiExtensionsV1beta1ReplicaSetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ReplicaSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ReplicaSet[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ReplicaSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ReplicaSet }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetCondition.jl deleted file mode 100644 index 0fe28b2b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ReplicaSetCondition -ReplicaSetCondition describes the state of a replica set at a certain point. - - IoK8sApiExtensionsV1beta1ReplicaSetCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of replica set condition. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ReplicaSetCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1ReplicaSetCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiExtensionsV1beta1ReplicaSetCondition - -const _property_types_IoK8sApiExtensionsV1beta1ReplicaSetCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ReplicaSetCondition[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ReplicaSetCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetList.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetList.jl deleted file mode 100644 index 5d830e6c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ReplicaSetList -ReplicaSetList is a collection of ReplicaSets. - - IoK8sApiExtensionsV1beta1ReplicaSetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiExtensionsV1beta1ReplicaSet} : List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ReplicaSetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1ReplicaSet} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiExtensionsV1beta1ReplicaSetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiExtensionsV1beta1ReplicaSetList - -const _property_types_IoK8sApiExtensionsV1beta1ReplicaSetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiExtensionsV1beta1ReplicaSet}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ReplicaSetList[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ReplicaSetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetSpec.jl deleted file mode 100644 index 9c9b158f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetSpec.jl +++ /dev/null @@ -1,49 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ReplicaSetSpec -ReplicaSetSpec is the specification of a ReplicaSet. - - IoK8sApiExtensionsV1beta1ReplicaSetSpec(; - minReadySeconds=nothing, - replicas=nothing, - selector=nothing, - template=nothing, - ) - - - minReadySeconds::Int64 : Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) - - replicas::Int64 : Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - template::IoK8sApiCoreV1PodTemplateSpec -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ReplicaSetSpec <: OpenAPI.APIModel - minReadySeconds::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - template = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } - - function IoK8sApiExtensionsV1beta1ReplicaSetSpec(minReadySeconds, replicas, selector, template, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetSpec, Symbol("minReadySeconds"), minReadySeconds) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetSpec, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetSpec, Symbol("template"), template) - return new(minReadySeconds, replicas, selector, template, ) - end -end # type IoK8sApiExtensionsV1beta1ReplicaSetSpec - -const _property_types_IoK8sApiExtensionsV1beta1ReplicaSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int64", Symbol("replicas")=>"Int64", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ReplicaSetSpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ReplicaSetSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetSpec }, name::Symbol, val) - if name === Symbol("minReadySeconds") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetSpec", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetStatus.jl deleted file mode 100644 index 24ac29ab..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ReplicaSetStatus.jl +++ /dev/null @@ -1,67 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ReplicaSetStatus -ReplicaSetStatus represents the current status of a ReplicaSet. - - IoK8sApiExtensionsV1beta1ReplicaSetStatus(; - availableReplicas=nothing, - conditions=nothing, - fullyLabeledReplicas=nothing, - observedGeneration=nothing, - readyReplicas=nothing, - replicas=nothing, - ) - - - availableReplicas::Int64 : The number of available replicas (ready for at least minReadySeconds) for this replica set. - - conditions::Vector{IoK8sApiExtensionsV1beta1ReplicaSetCondition} : Represents the latest available observations of a replica set's current state. - - fullyLabeledReplicas::Int64 : The number of pods that have labels matching the labels of the pod template of the replicaset. - - observedGeneration::Int64 : ObservedGeneration reflects the generation of the most recently observed ReplicaSet. - - readyReplicas::Int64 : The number of ready replicas for this replica set. - - replicas::Int64 : Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ReplicaSetStatus <: OpenAPI.APIModel - availableReplicas::Union{Nothing, Int64} = nothing - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1ReplicaSetCondition} } - fullyLabeledReplicas::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - readyReplicas::Union{Nothing, Int64} = nothing - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1ReplicaSetStatus(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("availableReplicas"), availableReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("fullyLabeledReplicas"), fullyLabeledReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("observedGeneration"), observedGeneration) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("readyReplicas"), readyReplicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ReplicaSetStatus, Symbol("replicas"), replicas) - return new(availableReplicas, conditions, fullyLabeledReplicas, observedGeneration, readyReplicas, replicas, ) - end -end # type IoK8sApiExtensionsV1beta1ReplicaSetStatus - -const _property_types_IoK8sApiExtensionsV1beta1ReplicaSetStatus = Dict{Symbol,String}(Symbol("availableReplicas")=>"Int64", Symbol("conditions")=>"Vector{IoK8sApiExtensionsV1beta1ReplicaSetCondition}", Symbol("fullyLabeledReplicas")=>"Int64", Symbol("observedGeneration")=>"Int64", Symbol("readyReplicas")=>"Int64", Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ReplicaSetStatus[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ReplicaSetStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ReplicaSetStatus }, name::Symbol, val) - if name === Symbol("availableReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("fullyLabeledReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetStatus", :format, val, "int64") - end - if name === Symbol("readyReplicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetStatus", :format, val, "int32") - end - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ReplicaSetStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollbackConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollbackConfig.jl deleted file mode 100644 index e9fec7d3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollbackConfig.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RollbackConfig -DEPRECATED. - - IoK8sApiExtensionsV1beta1RollbackConfig(; - revision=nothing, - ) - - - revision::Int64 : The revision to rollback to. If set to 0, rollback to the last revision. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RollbackConfig <: OpenAPI.APIModel - revision::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1RollbackConfig(revision, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RollbackConfig, Symbol("revision"), revision) - return new(revision, ) - end -end # type IoK8sApiExtensionsV1beta1RollbackConfig - -const _property_types_IoK8sApiExtensionsV1beta1RollbackConfig = Dict{Symbol,String}(Symbol("revision")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RollbackConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RollbackConfig[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RollbackConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RollbackConfig }, name::Symbol, val) - if name === Symbol("revision") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1RollbackConfig", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet.jl deleted file mode 100644 index b0999c7f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RollingUpdateDaemonSet -Spec to control the desired behavior of daemon set rolling update. - - IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet(; - maxUnavailable=nothing, - ) - - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet <: OpenAPI.APIModel - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet(maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet, Symbol("maxUnavailable"), maxUnavailable) - return new(maxUnavailable, ) - end -end # type IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet - -const _property_types_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet = Dict{Symbol,String}(Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet }, name::Symbol, val) - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDeployment.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDeployment.jl deleted file mode 100644 index 000004cd..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RollingUpdateDeployment.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RollingUpdateDeployment -Spec to control the desired behavior of rolling update. - - IoK8sApiExtensionsV1beta1RollingUpdateDeployment(; - maxSurge=nothing, - maxUnavailable=nothing, - ) - - - maxSurge::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RollingUpdateDeployment <: OpenAPI.APIModel - maxSurge::Union{Nothing, Any} = nothing - maxUnavailable::Union{Nothing, Any} = nothing - - function IoK8sApiExtensionsV1beta1RollingUpdateDeployment(maxSurge, maxUnavailable, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RollingUpdateDeployment, Symbol("maxSurge"), maxSurge) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RollingUpdateDeployment, Symbol("maxUnavailable"), maxUnavailable) - return new(maxSurge, maxUnavailable, ) - end -end # type IoK8sApiExtensionsV1beta1RollingUpdateDeployment - -const _property_types_IoK8sApiExtensionsV1beta1RollingUpdateDeployment = Dict{Symbol,String}(Symbol("maxSurge")=>"Any", Symbol("maxUnavailable")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RollingUpdateDeployment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RollingUpdateDeployment[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RollingUpdateDeployment) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RollingUpdateDeployment }, name::Symbol, val) - if name === Symbol("maxSurge") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1RollingUpdateDeployment", :format, val, "int-or-string") - end - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1RollingUpdateDeployment", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions.jl deleted file mode 100644 index 096ce03b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RunAsGroupStrategyOptions -RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsGroupStrategyOptions from policy API Group instead. - - IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiExtensionsV1beta1IDRange} : ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate the allowable RunAsGroup values that may be set. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiExtensionsV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions.jl deleted file mode 100644 index 770b5551..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RunAsUserStrategyOptions -RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsUserStrategyOptions from policy API Group instead. - - IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiExtensionsV1beta1IDRange} : ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate the allowable RunAsUser values that may be set. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiExtensionsV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions.jl deleted file mode 100644 index 39a6b466..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.RuntimeClassStrategyOptions -RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. - - IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions(; - allowedRuntimeClassNames=nothing, - defaultRuntimeClassName=nothing, - ) - - - allowedRuntimeClassNames::Vector{String} : allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of \"*\" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. - - defaultRuntimeClassName::String : defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions <: OpenAPI.APIModel - allowedRuntimeClassNames::Union{Nothing, Vector{String}} = nothing - defaultRuntimeClassName::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions(allowedRuntimeClassNames, defaultRuntimeClassName, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions, Symbol("allowedRuntimeClassNames"), allowedRuntimeClassNames) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions, Symbol("defaultRuntimeClassName"), defaultRuntimeClassName) - return new(allowedRuntimeClassNames, defaultRuntimeClassName, ) - end -end # type IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions = Dict{Symbol,String}(Symbol("allowedRuntimeClassNames")=>"Vector{String}", Symbol("defaultRuntimeClassName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions) - o.allowedRuntimeClassNames === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions.jl deleted file mode 100644 index 0be4f911..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.SELinuxStrategyOptions -SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use SELinuxStrategyOptions from policy API Group instead. - - IoK8sApiExtensionsV1beta1SELinuxStrategyOptions(; - rule=nothing, - seLinuxOptions=nothing, - ) - - - rule::String : rule is the strategy that will dictate the allowable labels that may be set. - - seLinuxOptions::IoK8sApiCoreV1SELinuxOptions -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1SELinuxStrategyOptions <: OpenAPI.APIModel - rule::Union{Nothing, String} = nothing - seLinuxOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SELinuxOptions } - - function IoK8sApiExtensionsV1beta1SELinuxStrategyOptions(rule, seLinuxOptions, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1SELinuxStrategyOptions, Symbol("rule"), rule) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1SELinuxStrategyOptions, Symbol("seLinuxOptions"), seLinuxOptions) - return new(rule, seLinuxOptions, ) - end -end # type IoK8sApiExtensionsV1beta1SELinuxStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions = Dict{Symbol,String}(Symbol("rule")=>"String", Symbol("seLinuxOptions")=>"IoK8sApiCoreV1SELinuxOptions", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1SELinuxStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1SELinuxStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1SELinuxStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1SELinuxStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Scale.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Scale.jl deleted file mode 100644 index 4f66cb98..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1Scale.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.Scale -represents a scaling request for a resource. - - IoK8sApiExtensionsV1beta1Scale(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiExtensionsV1beta1ScaleSpec - - status::IoK8sApiExtensionsV1beta1ScaleStatus -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1Scale <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1ScaleSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1ScaleStatus } - - function IoK8sApiExtensionsV1beta1Scale(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Scale, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Scale, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Scale, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Scale, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1Scale, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiExtensionsV1beta1Scale - -const _property_types_IoK8sApiExtensionsV1beta1Scale = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiExtensionsV1beta1ScaleSpec", Symbol("status")=>"IoK8sApiExtensionsV1beta1ScaleStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1Scale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1Scale[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1Scale) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1Scale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleSpec.jl deleted file mode 100644 index 8b74c607..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleSpec.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ScaleSpec -describes the attributes of a scale subresource - - IoK8sApiExtensionsV1beta1ScaleSpec(; - replicas=nothing, - ) - - - replicas::Int64 : desired number of instances for the scaled object. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ScaleSpec <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - - function IoK8sApiExtensionsV1beta1ScaleSpec(replicas, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ScaleSpec, Symbol("replicas"), replicas) - return new(replicas, ) - end -end # type IoK8sApiExtensionsV1beta1ScaleSpec - -const _property_types_IoK8sApiExtensionsV1beta1ScaleSpec = Dict{Symbol,String}(Symbol("replicas")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ScaleSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ScaleSpec[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ScaleSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ScaleSpec }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ScaleSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleStatus.jl deleted file mode 100644 index f95e84bc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1ScaleStatus.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.ScaleStatus -represents the current status of a scale subresource. - - IoK8sApiExtensionsV1beta1ScaleStatus(; - replicas=nothing, - selector=nothing, - targetSelector=nothing, - ) - - - replicas::Int64 : actual number of observed instances of the scaled object. - - selector::Dict{String, String} : label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors - - targetSelector::String : label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1ScaleStatus <: OpenAPI.APIModel - replicas::Union{Nothing, Int64} = nothing - selector::Union{Nothing, Dict{String, String}} = nothing - targetSelector::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1ScaleStatus(replicas, selector, targetSelector, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ScaleStatus, Symbol("replicas"), replicas) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ScaleStatus, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1ScaleStatus, Symbol("targetSelector"), targetSelector) - return new(replicas, selector, targetSelector, ) - end -end # type IoK8sApiExtensionsV1beta1ScaleStatus - -const _property_types_IoK8sApiExtensionsV1beta1ScaleStatus = Dict{Symbol,String}(Symbol("replicas")=>"Int64", Symbol("selector")=>"Dict{String, String}", Symbol("targetSelector")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1ScaleStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1ScaleStatus[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1ScaleStatus) - o.replicas === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1ScaleStatus }, name::Symbol, val) - if name === Symbol("replicas") - OpenAPI.validate_param(name, "IoK8sApiExtensionsV1beta1ScaleStatus", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions.jl deleted file mode 100644 index 7084bd03..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.extensions.v1beta1.SupplementalGroupsStrategyOptions -SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use SupplementalGroupsStrategyOptions from policy API Group instead. - - IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiExtensionsV1beta1IDRange} : ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate what supplemental groups is used in the SecurityContext. -""" -Base.@kwdef mutable struct IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiExtensionsV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions - -const _property_types_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiExtensionsV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions[name]))} - -function check_required(o::IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod.jl deleted file mode 100644 index 92db228f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowDistinguisherMethod -FlowDistinguisherMethod specifies the method of a flow distinguisher. - - IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod(; - type=nothing, - ) - - - type::String : `type` is the type of flow distinguisher method The supported types are \"ByUser\" and \"ByNamespace\". Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod <: OpenAPI.APIModel - type::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod(type, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod, Symbol("type"), type) - return new(type, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod = Dict{Symbol,String}(Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchema.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchema.jl deleted file mode 100644 index eef9004a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchema.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowSchema -FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a \"flow distinguisher\". - - IoK8sApiFlowcontrolV1alpha1FlowSchema(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec - - status::IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowSchema <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus } - - function IoK8sApiFlowcontrolV1alpha1FlowSchema(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchema, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchema, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchema, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchema, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchema, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowSchema - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowSchema = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec", Symbol("status")=>"IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchema }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowSchema[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowSchema) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchema }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition.jl deleted file mode 100644 index 45024601..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowSchemaCondition -FlowSchemaCondition describes conditions for a FlowSchema. - - IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : `message` is a human-readable message indicating details about last transition. - - reason::String : `reason` is a unique, one-word, CamelCase reason for the condition's last transition. - - status::String : `status` is the status of the condition. Can be True, False, Unknown. Required. - - type::String : `type` is the type of the condition. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaList.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaList.jl deleted file mode 100644 index 04418e5c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowSchemaList -FlowSchemaList is a list of FlowSchema objects. - - IoK8sApiFlowcontrolV1alpha1FlowSchemaList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiFlowcontrolV1alpha1FlowSchema} : `items` is a list of FlowSchemas. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowSchemaList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1FlowSchema} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiFlowcontrolV1alpha1FlowSchemaList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowSchemaList - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiFlowcontrolV1alpha1FlowSchema}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaList[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowSchemaList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec.jl deleted file mode 100644 index ae3e6dc8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowSchemaSpec -FlowSchemaSpec describes how the FlowSchema's specification looks like. - - IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec(; - distinguisherMethod=nothing, - matchingPrecedence=nothing, - priorityLevelConfiguration=nothing, - rules=nothing, - ) - - - distinguisherMethod::IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod - - matchingPrecedence::Int64 : `matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen FlowSchema is among those with the numerically lowest (which we take to be logically highest) MatchingPrecedence. Each MatchingPrecedence value must be non-negative. Note that if the precedence is not specified or zero, it will be set to 1000 as default. - - priorityLevelConfiguration::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference - - rules::Vector{IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects} : `rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if at least one member of rules matches the request. if it is an empty slice, there will be no requests matching the FlowSchema. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec <: OpenAPI.APIModel - distinguisherMethod = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod } - matchingPrecedence::Union{Nothing, Int64} = nothing - priorityLevelConfiguration = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects} } - - function IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec(distinguisherMethod, matchingPrecedence, priorityLevelConfiguration, rules, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec, Symbol("distinguisherMethod"), distinguisherMethod) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec, Symbol("matchingPrecedence"), matchingPrecedence) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec, Symbol("priorityLevelConfiguration"), priorityLevelConfiguration) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec, Symbol("rules"), rules) - return new(distinguisherMethod, matchingPrecedence, priorityLevelConfiguration, rules, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec = Dict{Symbol,String}(Symbol("distinguisherMethod")=>"IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod", Symbol("matchingPrecedence")=>"Int64", Symbol("priorityLevelConfiguration")=>"IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference", Symbol("rules")=>"Vector{IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec) - o.priorityLevelConfiguration === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec }, name::Symbol, val) - if name === Symbol("matchingPrecedence") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus.jl deleted file mode 100644 index bb6df0d0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.FlowSchemaStatus -FlowSchemaStatus represents the current state of a FlowSchema. - - IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus(; - conditions=nothing, - ) - - - conditions::Vector{IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition} : `conditions` is a list of the current states of FlowSchema. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition} } - - function IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus(conditions, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus, Symbol("conditions"), conditions) - return new(conditions, ) - end -end # type IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus - -const _property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1GroupSubject.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1GroupSubject.jl deleted file mode 100644 index 8d19438a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1GroupSubject.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.GroupSubject -GroupSubject holds detailed information for group-kind subject. - - IoK8sApiFlowcontrolV1alpha1GroupSubject(; - name=nothing, - ) - - - name::String : name is the user group that matches, or \"*\" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1GroupSubject <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1GroupSubject(name, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1GroupSubject, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiFlowcontrolV1alpha1GroupSubject - -const _property_types_IoK8sApiFlowcontrolV1alpha1GroupSubject = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1GroupSubject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1GroupSubject[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1GroupSubject) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1GroupSubject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitResponse.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitResponse.jl deleted file mode 100644 index fc0c6095..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitResponse.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.LimitResponse -LimitResponse defines how to handle requests that can not be executed right now. - - IoK8sApiFlowcontrolV1alpha1LimitResponse(; - queuing=nothing, - type=nothing, - ) - - - queuing::IoK8sApiFlowcontrolV1alpha1QueuingConfiguration - - type::String : `type` is \"Queue\" or \"Reject\". \"Queue\" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. \"Reject\" means that requests that can not be executed upon arrival are rejected. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1LimitResponse <: OpenAPI.APIModel - queuing = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1QueuingConfiguration } - type::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1LimitResponse(queuing, type, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1LimitResponse, Symbol("queuing"), queuing) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1LimitResponse, Symbol("type"), type) - return new(queuing, type, ) - end -end # type IoK8sApiFlowcontrolV1alpha1LimitResponse - -const _property_types_IoK8sApiFlowcontrolV1alpha1LimitResponse = Dict{Symbol,String}(Symbol("queuing")=>"IoK8sApiFlowcontrolV1alpha1QueuingConfiguration", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1LimitResponse }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1LimitResponse[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1LimitResponse) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1LimitResponse }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration.jl deleted file mode 100644 index 5a44877a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration -LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: * How are requests for this priority level limited? * What should be done with requests that exceed the limit? - - IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration(; - assuredConcurrencyShares=nothing, - limitResponse=nothing, - ) - - - assuredConcurrencyShares::Int64 : `assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) bigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30. - - limitResponse::IoK8sApiFlowcontrolV1alpha1LimitResponse -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration <: OpenAPI.APIModel - assuredConcurrencyShares::Union{Nothing, Int64} = nothing - limitResponse = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1LimitResponse } - - function IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration(assuredConcurrencyShares, limitResponse, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration, Symbol("assuredConcurrencyShares"), assuredConcurrencyShares) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration, Symbol("limitResponse"), limitResponse) - return new(assuredConcurrencyShares, limitResponse, ) - end -end # type IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration - -const _property_types_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration = Dict{Symbol,String}(Symbol("assuredConcurrencyShares")=>"Int64", Symbol("limitResponse")=>"IoK8sApiFlowcontrolV1alpha1LimitResponse", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration }, name::Symbol, val) - if name === Symbol("assuredConcurrencyShares") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule.jl deleted file mode 100644 index 80901d27..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule -NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. - - IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule(; - nonResourceURLs=nothing, - verbs=nothing, - ) - - - nonResourceURLs::Vector{String} : `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: - \"/healthz\" is legal - \"/hea*\" is illegal - \"/hea\" is legal but matches nothing - \"/hea/*\" also matches nothing - \"/healthz/*\" matches all per-component health checks. \"*\" matches all non-resource urls. if it is present, it must be the only entry. Required. - - verbs::Vector{String} : `verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs. If it is present, it must be the only entry. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule <: OpenAPI.APIModel - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule(nonResourceURLs, verbs, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule, Symbol("verbs"), verbs) - return new(nonResourceURLs, verbs, ) - end -end # type IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule - -const _property_types_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule = Dict{Symbol,String}(Symbol("nonResourceURLs")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule) - o.nonResourceURLs === nothing && (return false) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects.jl deleted file mode 100644 index 08502600..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects -PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request. - - IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects(; - nonResourceRules=nothing, - resourceRules=nothing, - subjects=nothing, - ) - - - nonResourceRules::Vector{IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule} : `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. - - resourceRules::Vector{IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule} : `resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the target resource. At least one of `resourceRules` and `nonResourceRules` has to be non-empty. - - subjects::Vector{IoK8sApiFlowcontrolV1alpha1Subject} : subjects is the list of normal user, serviceaccount, or group that this rule cares about. There must be at least one member in this slice. A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects <: OpenAPI.APIModel - nonResourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule} } - resourceRules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule} } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1Subject} } - - function IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects(nonResourceRules, resourceRules, subjects, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects, Symbol("nonResourceRules"), nonResourceRules) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects, Symbol("resourceRules"), resourceRules) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects, Symbol("subjects"), subjects) - return new(nonResourceRules, resourceRules, subjects, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects - -const _property_types_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects = Dict{Symbol,String}(Symbol("nonResourceRules")=>"Vector{IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule}", Symbol("resourceRules")=>"Vector{IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule}", Symbol("subjects")=>"Vector{IoK8sApiFlowcontrolV1alpha1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects) - o.subjects === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration.jl deleted file mode 100644 index 7319f48a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfiguration -PriorityLevelConfiguration represents the configuration of a priority level. - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec - - status::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus } - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec", Symbol("status")=>"IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition.jl deleted file mode 100644 index f59c6efe..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationCondition -PriorityLevelConfigurationCondition defines the condition of priority level. - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : `message` is a human-readable message indicating details about last transition. - - reason::String : `reason` is a unique, one-word, CamelCase reason for the condition's last transition. - - status::String : `status` is the status of the condition. Can be True, False, Unknown. Required. - - type::String : `type` is the type of the condition. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList.jl deleted file mode 100644 index b50f248a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationList -PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration} : `items` is a list of request-priorities. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference.jl deleted file mode 100644 index 594d9171..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationReference -PriorityLevelConfigurationReference contains information that points to the \"request-priority\" being used. - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference(; - name=nothing, - ) - - - name::String : `name` is the name of the priority level configuration being referenced Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference(name, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec.jl deleted file mode 100644 index 9de51b51..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec -PriorityLevelConfigurationSpec specifies the configuration of a priority level. - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec(; - limited=nothing, - type=nothing, - ) - - - limited::IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration - - type::String : `type` indicates whether this priority level is subject to limitation on request execution. A value of `\"Exempt\"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `\"Limited\"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec <: OpenAPI.APIModel - limited = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration } - type::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec(limited, type, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec, Symbol("limited"), limited) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec, Symbol("type"), type) - return new(limited, type, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec = Dict{Symbol,String}(Symbol("limited")=>"IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus.jl deleted file mode 100644 index 0af88538..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus -PriorityLevelConfigurationStatus represents the current state of a \"request-priority\". - - IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus(; - conditions=nothing, - ) - - - conditions::Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition} : `conditions` is the current state of \"request-priority\". -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition} } - - function IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus(conditions, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus, Symbol("conditions"), conditions) - return new(conditions, ) - end -end # type IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus - -const _property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration.jl deleted file mode 100644 index 886103fa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration -QueuingConfiguration holds the configuration parameters for queuing - - IoK8sApiFlowcontrolV1alpha1QueuingConfiguration(; - handSize=nothing, - queueLengthLimit=nothing, - queues=nothing, - ) - - - handSize::Int64 : `handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. - - queueLengthLimit::Int64 : `queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50. - - queues::Int64 : `queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1QueuingConfiguration <: OpenAPI.APIModel - handSize::Union{Nothing, Int64} = nothing - queueLengthLimit::Union{Nothing, Int64} = nothing - queues::Union{Nothing, Int64} = nothing - - function IoK8sApiFlowcontrolV1alpha1QueuingConfiguration(handSize, queueLengthLimit, queues, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1QueuingConfiguration, Symbol("handSize"), handSize) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1QueuingConfiguration, Symbol("queueLengthLimit"), queueLengthLimit) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1QueuingConfiguration, Symbol("queues"), queues) - return new(handSize, queueLengthLimit, queues, ) - end -end # type IoK8sApiFlowcontrolV1alpha1QueuingConfiguration - -const _property_types_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration = Dict{Symbol,String}(Symbol("handSize")=>"Int64", Symbol("queueLengthLimit")=>"Int64", Symbol("queues")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1QueuingConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1QueuingConfiguration[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1QueuingConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1QueuingConfiguration }, name::Symbol, val) - if name === Symbol("handSize") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1QueuingConfiguration", :format, val, "int32") - end - if name === Symbol("queueLengthLimit") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1QueuingConfiguration", :format, val, "int32") - end - if name === Symbol("queues") - OpenAPI.validate_param(name, "IoK8sApiFlowcontrolV1alpha1QueuingConfiguration", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule.jl deleted file mode 100644 index 1583e6aa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule.jl +++ /dev/null @@ -1,50 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.ResourcePolicyRule -ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request. - - IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule(; - apiGroups=nothing, - clusterScope=nothing, - namespaces=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : `apiGroups` is a list of matching API groups and may not be empty. \"*\" matches all API groups and, if present, must be the only entry. Required. - - clusterScope::Bool : `clusterScope` indicates whether to match requests that do not specify a namespace (which happens either because the resource is not namespaced or the request targets all namespaces). If this field is omitted or false then the `namespaces` field must contain a non-empty list. - - namespaces::Vector{String} : `namespaces` is a list of target namespaces that restricts matches. A request that specifies a target namespace matches only if either (a) this list contains that target namespace or (b) this list contains \"*\". Note that \"*\" matches any specified namespace but does not match a request that _does not specify_ a namespace (see the `clusterScope` field for that). This list may be empty, but only if `clusterScope` is true. - - resources::Vector{String} : `resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ \"services\", \"nodes/status\" ]. This list may not be empty. \"*\" matches all resources and, if present, must be the only entry. Required. - - verbs::Vector{String} : `verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs and, if present, must be the only entry. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - clusterScope::Union{Nothing, Bool} = nothing - namespaces::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule(apiGroups, clusterScope, namespaces, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule, Symbol("clusterScope"), clusterScope) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule, Symbol("namespaces"), namespaces) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule, Symbol("verbs"), verbs) - return new(apiGroups, clusterScope, namespaces, resources, verbs, ) - end -end # type IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule - -const _property_types_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("clusterScope")=>"Bool", Symbol("namespaces")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule) - o.apiGroups === nothing && (return false) - o.resources === nothing && (return false) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject.jl deleted file mode 100644 index 3169e6ae..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.ServiceAccountSubject -ServiceAccountSubject holds detailed information for service-account-kind subject. - - IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject(; - name=nothing, - namespace=nothing, - ) - - - name::String : `name` is the name of matching ServiceAccount objects, or \"*\" to match regardless of name. Required. - - namespace::String : `namespace` is the namespace of matching ServiceAccount objects. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject(name, namespace, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject, Symbol("namespace"), namespace) - return new(name, namespace, ) - end -end # type IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject - -const _property_types_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1Subject.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1Subject.jl deleted file mode 100644 index 30ebc65f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1Subject.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.Subject -Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account. - - IoK8sApiFlowcontrolV1alpha1Subject(; - group=nothing, - kind=nothing, - serviceAccount=nothing, - user=nothing, - ) - - - group::IoK8sApiFlowcontrolV1alpha1GroupSubject - - kind::String : Required - - serviceAccount::IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject - - user::IoK8sApiFlowcontrolV1alpha1UserSubject -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1Subject <: OpenAPI.APIModel - group = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1GroupSubject } - kind::Union{Nothing, String} = nothing - serviceAccount = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject } - user = nothing # spec type: Union{ Nothing, IoK8sApiFlowcontrolV1alpha1UserSubject } - - function IoK8sApiFlowcontrolV1alpha1Subject(group, kind, serviceAccount, user, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1Subject, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1Subject, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1Subject, Symbol("serviceAccount"), serviceAccount) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1Subject, Symbol("user"), user) - return new(group, kind, serviceAccount, user, ) - end -end # type IoK8sApiFlowcontrolV1alpha1Subject - -const _property_types_IoK8sApiFlowcontrolV1alpha1Subject = Dict{Symbol,String}(Symbol("group")=>"IoK8sApiFlowcontrolV1alpha1GroupSubject", Symbol("kind")=>"String", Symbol("serviceAccount")=>"IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject", Symbol("user")=>"IoK8sApiFlowcontrolV1alpha1UserSubject", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1Subject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1Subject[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1Subject) - o.kind === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1Subject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1UserSubject.jl b/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1UserSubject.jl deleted file mode 100644 index f30a8945..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiFlowcontrolV1alpha1UserSubject.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.flowcontrol.v1alpha1.UserSubject -UserSubject holds detailed information for user-kind subject. - - IoK8sApiFlowcontrolV1alpha1UserSubject(; - name=nothing, - ) - - - name::String : `name` is the username that matches, or \"*\" to match all usernames. Required. -""" -Base.@kwdef mutable struct IoK8sApiFlowcontrolV1alpha1UserSubject <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiFlowcontrolV1alpha1UserSubject(name, ) - OpenAPI.validate_property(IoK8sApiFlowcontrolV1alpha1UserSubject, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiFlowcontrolV1alpha1UserSubject - -const _property_types_IoK8sApiFlowcontrolV1alpha1UserSubject = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiFlowcontrolV1alpha1UserSubject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiFlowcontrolV1alpha1UserSubject[name]))} - -function check_required(o::IoK8sApiFlowcontrolV1alpha1UserSubject) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiFlowcontrolV1alpha1UserSubject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1ContainerMetrics.jl b/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1ContainerMetrics.jl deleted file mode 100644 index a17ca6f8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1ContainerMetrics.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.metrics.v1beta1.ContainerMetrics -ContainerMetrics sets resource usage metrics of a container. - - IoK8sApiMetricsV1beta1ContainerMetrics(; - name=nothing, - usage=nothing, - ) - - - name::String : Container name corresponding to the one from pod.spec.containers. - - usage::Dict{String, String} : The memory usage is the memory working set. -""" -Base.@kwdef mutable struct IoK8sApiMetricsV1beta1ContainerMetrics <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - usage::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiMetricsV1beta1ContainerMetrics(name, usage, ) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1ContainerMetrics, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1ContainerMetrics, Symbol("usage"), usage) - return new(name, usage, ) - end -end # type IoK8sApiMetricsV1beta1ContainerMetrics - -const _property_types_IoK8sApiMetricsV1beta1ContainerMetrics = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("usage")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiMetricsV1beta1ContainerMetrics }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiMetricsV1beta1ContainerMetrics[name]))} - -function check_required(o::IoK8sApiMetricsV1beta1ContainerMetrics) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiMetricsV1beta1ContainerMetrics }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetrics.jl b/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetrics.jl deleted file mode 100644 index d8ad42fc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetrics.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.metrics.v1beta1.NodeMetrics -NodeMetrics sets resource usage metrics of a node. - - IoK8sApiMetricsV1beta1NodeMetrics(; - metadata=nothing, - timestamp=nothing, - usage=nothing, - window=nothing, - ) - - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - timestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - usage::Dict{String, String} : The memory usage is the memory working set. - - window::String : Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json. -""" -Base.@kwdef mutable struct IoK8sApiMetricsV1beta1NodeMetrics <: OpenAPI.APIModel - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - timestamp::Union{Nothing, ZonedDateTime} = nothing - usage::Union{Nothing, Dict{String, String}} = nothing - window::Union{Nothing, String} = nothing - - function IoK8sApiMetricsV1beta1NodeMetrics(metadata, timestamp, usage, window, ) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetrics, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetrics, Symbol("timestamp"), timestamp) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetrics, Symbol("usage"), usage) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetrics, Symbol("window"), window) - return new(metadata, timestamp, usage, window, ) - end -end # type IoK8sApiMetricsV1beta1NodeMetrics - -const _property_types_IoK8sApiMetricsV1beta1NodeMetrics = Dict{Symbol,String}(Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("timestamp")=>"ZonedDateTime", Symbol("usage")=>"Dict{String, String}", Symbol("window")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiMetricsV1beta1NodeMetrics }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiMetricsV1beta1NodeMetrics[name]))} - -function check_required(o::IoK8sApiMetricsV1beta1NodeMetrics) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiMetricsV1beta1NodeMetrics }, name::Symbol, val) - if name === Symbol("timestamp") - OpenAPI.validate_param(name, "IoK8sApiMetricsV1beta1NodeMetrics", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetricsList.jl b/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetricsList.jl deleted file mode 100644 index 430eb65e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1NodeMetricsList.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.metrics.v1beta1.NodeMetricsList -NodeMetricsList is a list of NodeMetrics. - - IoK8sApiMetricsV1beta1NodeMetricsList(; - items=nothing, - metadata=nothing, - ) - - - items::Vector{IoK8sApiMetricsV1beta1NodeMetrics} : List of node metrics. - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiMetricsV1beta1NodeMetricsList <: OpenAPI.APIModel - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiMetricsV1beta1NodeMetrics} } - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiMetricsV1beta1NodeMetricsList(items, metadata, ) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetricsList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1NodeMetricsList, Symbol("metadata"), metadata) - return new(items, metadata, ) - end -end # type IoK8sApiMetricsV1beta1NodeMetricsList - -const _property_types_IoK8sApiMetricsV1beta1NodeMetricsList = Dict{Symbol,String}(Symbol("items")=>"Vector{IoK8sApiMetricsV1beta1NodeMetrics}", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiMetricsV1beta1NodeMetricsList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiMetricsV1beta1NodeMetricsList[name]))} - -function check_required(o::IoK8sApiMetricsV1beta1NodeMetricsList) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiMetricsV1beta1NodeMetricsList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetrics.jl b/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetrics.jl deleted file mode 100644 index c6c2074b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetrics.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.metrics.v1beta1.PodMetrics -PodMetrics sets resource usage metrics of a pod. - - IoK8sApiMetricsV1beta1PodMetrics(; - containers=nothing, - metadata=nothing, - timestamp=nothing, - window=nothing, - ) - - - containers::Vector{IoK8sApiMetricsV1beta1ContainerMetrics} : Metrics for all containers are collected within the same time window. - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - timestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - window::String : Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json. -""" -Base.@kwdef mutable struct IoK8sApiMetricsV1beta1PodMetrics <: OpenAPI.APIModel - containers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiMetricsV1beta1ContainerMetrics} } - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - timestamp::Union{Nothing, ZonedDateTime} = nothing - window::Union{Nothing, String} = nothing - - function IoK8sApiMetricsV1beta1PodMetrics(containers, metadata, timestamp, window, ) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetrics, Symbol("containers"), containers) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetrics, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetrics, Symbol("timestamp"), timestamp) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetrics, Symbol("window"), window) - return new(containers, metadata, timestamp, window, ) - end -end # type IoK8sApiMetricsV1beta1PodMetrics - -const _property_types_IoK8sApiMetricsV1beta1PodMetrics = Dict{Symbol,String}(Symbol("containers")=>"Vector{IoK8sApiMetricsV1beta1ContainerMetrics}", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("timestamp")=>"ZonedDateTime", Symbol("window")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiMetricsV1beta1PodMetrics }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiMetricsV1beta1PodMetrics[name]))} - -function check_required(o::IoK8sApiMetricsV1beta1PodMetrics) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiMetricsV1beta1PodMetrics }, name::Symbol, val) - if name === Symbol("timestamp") - OpenAPI.validate_param(name, "IoK8sApiMetricsV1beta1PodMetrics", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetricsList.jl b/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetricsList.jl deleted file mode 100644 index 39be09d5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiMetricsV1beta1PodMetricsList.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.metrics.v1beta1.PodMetricsList -PodMetricsList is a list of PodMetrics. - - IoK8sApiMetricsV1beta1PodMetricsList(; - items=nothing, - metadata=nothing, - ) - - - items::Vector{IoK8sApiMetricsV1beta1PodMetrics} : List of pod metrics. - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiMetricsV1beta1PodMetricsList <: OpenAPI.APIModel - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiMetricsV1beta1PodMetrics} } - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiMetricsV1beta1PodMetricsList(items, metadata, ) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetricsList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiMetricsV1beta1PodMetricsList, Symbol("metadata"), metadata) - return new(items, metadata, ) - end -end # type IoK8sApiMetricsV1beta1PodMetricsList - -const _property_types_IoK8sApiMetricsV1beta1PodMetricsList = Dict{Symbol,String}(Symbol("items")=>"Vector{IoK8sApiMetricsV1beta1PodMetrics}", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiMetricsV1beta1PodMetricsList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiMetricsV1beta1PodMetricsList[name]))} - -function check_required(o::IoK8sApiMetricsV1beta1PodMetricsList) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiMetricsV1beta1PodMetricsList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1IPBlock.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1IPBlock.jl deleted file mode 100644 index 0d25838e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1IPBlock.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.IPBlock -IPBlock describes a particular CIDR (Ex. \"192.168.1.1/24\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule. - - IoK8sApiNetworkingV1IPBlock(; - cidr=nothing, - except=nothing, - ) - - - cidr::String : CIDR is a string representing the IP Block Valid examples are \"192.168.1.1/24\" - - except::Vector{String} : Except is a slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" Except values will be rejected if they are outside the CIDR range -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1IPBlock <: OpenAPI.APIModel - cidr::Union{Nothing, String} = nothing - except::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiNetworkingV1IPBlock(cidr, except, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1IPBlock, Symbol("cidr"), cidr) - OpenAPI.validate_property(IoK8sApiNetworkingV1IPBlock, Symbol("except"), except) - return new(cidr, except, ) - end -end # type IoK8sApiNetworkingV1IPBlock - -const _property_types_IoK8sApiNetworkingV1IPBlock = Dict{Symbol,String}(Symbol("cidr")=>"String", Symbol("except")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1IPBlock }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1IPBlock[name]))} - -function check_required(o::IoK8sApiNetworkingV1IPBlock) - o.cidr === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1IPBlock }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicy.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicy.jl deleted file mode 100644 index 92274efb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicy.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicy -NetworkPolicy describes what network traffic is allowed for a set of Pods - - IoK8sApiNetworkingV1NetworkPolicy(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiNetworkingV1NetworkPolicySpec -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicy <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1NetworkPolicySpec } - - function IoK8sApiNetworkingV1NetworkPolicy(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicy, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicy, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicy, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicy, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicy - -const _property_types_IoK8sApiNetworkingV1NetworkPolicy = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiNetworkingV1NetworkPolicySpec", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicy[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyEgressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyEgressRule.jl deleted file mode 100644 index ff6d78a7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyEgressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicyEgressRule -NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 - - IoK8sApiNetworkingV1NetworkPolicyEgressRule(; - ports=nothing, - to=nothing, - ) - - - ports::Vector{IoK8sApiNetworkingV1NetworkPolicyPort} : List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. - - to::Vector{IoK8sApiNetworkingV1NetworkPolicyPeer} : List of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicyEgressRule <: OpenAPI.APIModel - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyPort} } - to::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyPeer} } - - function IoK8sApiNetworkingV1NetworkPolicyEgressRule(ports, to, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyEgressRule, Symbol("ports"), ports) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyEgressRule, Symbol("to"), to) - return new(ports, to, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicyEgressRule - -const _property_types_IoK8sApiNetworkingV1NetworkPolicyEgressRule = Dict{Symbol,String}(Symbol("ports")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyPort}", Symbol("to")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicyEgressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicyEgressRule[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicyEgressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicyEgressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyIngressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyIngressRule.jl deleted file mode 100644 index 1c825136..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyIngressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicyIngressRule -NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from. - - IoK8sApiNetworkingV1NetworkPolicyIngressRule(; - from=nothing, - ports=nothing, - ) - - - from::Vector{IoK8sApiNetworkingV1NetworkPolicyPeer} : List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. - - ports::Vector{IoK8sApiNetworkingV1NetworkPolicyPort} : List of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicyIngressRule <: OpenAPI.APIModel - from::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyPeer} } - ports::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyPort} } - - function IoK8sApiNetworkingV1NetworkPolicyIngressRule(from, ports, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyIngressRule, Symbol("from"), from) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyIngressRule, Symbol("ports"), ports) - return new(from, ports, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicyIngressRule - -const _property_types_IoK8sApiNetworkingV1NetworkPolicyIngressRule = Dict{Symbol,String}(Symbol("from")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}", Symbol("ports")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyPort}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicyIngressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicyIngressRule[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicyIngressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicyIngressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyList.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyList.jl deleted file mode 100644 index 4ead92b4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicyList -NetworkPolicyList is a list of NetworkPolicy objects. - - IoK8sApiNetworkingV1NetworkPolicyList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiNetworkingV1NetworkPolicy} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicyList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicy} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiNetworkingV1NetworkPolicyList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicyList - -const _property_types_IoK8sApiNetworkingV1NetworkPolicyList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiNetworkingV1NetworkPolicy}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicyList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicyList[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicyList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicyList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPeer.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPeer.jl deleted file mode 100644 index cdbc9ae9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPeer.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicyPeer -NetworkPolicyPeer describes a peer to allow traffic from. Only certain combinations of fields are allowed - - IoK8sApiNetworkingV1NetworkPolicyPeer(; - ipBlock=nothing, - namespaceSelector=nothing, - podSelector=nothing, - ) - - - ipBlock::IoK8sApiNetworkingV1IPBlock - - namespaceSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - podSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicyPeer <: OpenAPI.APIModel - ipBlock = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1IPBlock } - namespaceSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - podSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiNetworkingV1NetworkPolicyPeer(ipBlock, namespaceSelector, podSelector, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyPeer, Symbol("ipBlock"), ipBlock) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyPeer, Symbol("namespaceSelector"), namespaceSelector) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyPeer, Symbol("podSelector"), podSelector) - return new(ipBlock, namespaceSelector, podSelector, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicyPeer - -const _property_types_IoK8sApiNetworkingV1NetworkPolicyPeer = Dict{Symbol,String}(Symbol("ipBlock")=>"IoK8sApiNetworkingV1IPBlock", Symbol("namespaceSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("podSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicyPeer }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicyPeer[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicyPeer) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicyPeer }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPort.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPort.jl deleted file mode 100644 index cbb70a64..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicyPort.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicyPort -NetworkPolicyPort describes a port to allow traffic on - - IoK8sApiNetworkingV1NetworkPolicyPort(; - port=nothing, - protocol=nothing, - ) - - - port::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - protocol::String : The protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicyPort <: OpenAPI.APIModel - port::Union{Nothing, Any} = nothing - protocol::Union{Nothing, String} = nothing - - function IoK8sApiNetworkingV1NetworkPolicyPort(port, protocol, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyPort, Symbol("port"), port) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicyPort, Symbol("protocol"), protocol) - return new(port, protocol, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicyPort - -const _property_types_IoK8sApiNetworkingV1NetworkPolicyPort = Dict{Symbol,String}(Symbol("port")=>"Any", Symbol("protocol")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicyPort }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicyPort[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicyPort) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicyPort }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiNetworkingV1NetworkPolicyPort", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicySpec.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicySpec.jl deleted file mode 100644 index 23981605..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1NetworkPolicySpec.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1.NetworkPolicySpec -NetworkPolicySpec provides the specification of a NetworkPolicy - - IoK8sApiNetworkingV1NetworkPolicySpec(; - egress=nothing, - ingress=nothing, - podSelector=nothing, - policyTypes=nothing, - ) - - - egress::Vector{IoK8sApiNetworkingV1NetworkPolicyEgressRule} : List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 - - ingress::Vector{IoK8sApiNetworkingV1NetworkPolicyIngressRule} : List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default) - - podSelector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - policyTypes::Vector{String} : List of rule types that the NetworkPolicy relates to. Valid options are \"Ingress\", \"Egress\", or \"Ingress,Egress\". If this field is not specified, it will default based on the existence of Ingress or Egress rules; policies that contain an Egress section are assumed to affect Egress, and all policies (whether or not they contain an Ingress section) are assumed to affect Ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an Egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8 -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1NetworkPolicySpec <: OpenAPI.APIModel - egress::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyEgressRule} } - ingress::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1NetworkPolicyIngressRule} } - podSelector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - policyTypes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiNetworkingV1NetworkPolicySpec(egress, ingress, podSelector, policyTypes, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicySpec, Symbol("egress"), egress) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicySpec, Symbol("ingress"), ingress) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicySpec, Symbol("podSelector"), podSelector) - OpenAPI.validate_property(IoK8sApiNetworkingV1NetworkPolicySpec, Symbol("policyTypes"), policyTypes) - return new(egress, ingress, podSelector, policyTypes, ) - end -end # type IoK8sApiNetworkingV1NetworkPolicySpec - -const _property_types_IoK8sApiNetworkingV1NetworkPolicySpec = Dict{Symbol,String}(Symbol("egress")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyEgressRule}", Symbol("ingress")=>"Vector{IoK8sApiNetworkingV1NetworkPolicyIngressRule}", Symbol("podSelector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("policyTypes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1NetworkPolicySpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1NetworkPolicySpec[name]))} - -function check_required(o::IoK8sApiNetworkingV1NetworkPolicySpec) - o.podSelector === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1NetworkPolicySpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressPath.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressPath.jl deleted file mode 100644 index 919cbd1c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressPath.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.HTTPIngressPath -HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. - - IoK8sApiNetworkingV1beta1HTTPIngressPath(; - backend=nothing, - path=nothing, - ) - - - backend::IoK8sApiNetworkingV1beta1IngressBackend - - path::String : Path is an extended POSIX regex as defined by IEEE Std 1003.1, (i.e this follows the egrep/unix syntax, not the perl syntax) matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a '/'. If unspecified, the path defaults to a catch all sending traffic to the backend. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1HTTPIngressPath <: OpenAPI.APIModel - backend = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1beta1IngressBackend } - path::Union{Nothing, String} = nothing - - function IoK8sApiNetworkingV1beta1HTTPIngressPath(backend, path, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1HTTPIngressPath, Symbol("backend"), backend) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1HTTPIngressPath, Symbol("path"), path) - return new(backend, path, ) - end -end # type IoK8sApiNetworkingV1beta1HTTPIngressPath - -const _property_types_IoK8sApiNetworkingV1beta1HTTPIngressPath = Dict{Symbol,String}(Symbol("backend")=>"IoK8sApiNetworkingV1beta1IngressBackend", Symbol("path")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1HTTPIngressPath }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1HTTPIngressPath[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1HTTPIngressPath) - o.backend === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1HTTPIngressPath }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue.jl deleted file mode 100644 index 3e266506..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.HTTPIngressRuleValue -HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http://<host>/<path>?<searchpart> -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'. - - IoK8sApiNetworkingV1beta1HTTPIngressRuleValue(; - paths=nothing, - ) - - - paths::Vector{IoK8sApiNetworkingV1beta1HTTPIngressPath} : A collection of paths that map requests to backends. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1HTTPIngressRuleValue <: OpenAPI.APIModel - paths::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1beta1HTTPIngressPath} } - - function IoK8sApiNetworkingV1beta1HTTPIngressRuleValue(paths, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1HTTPIngressRuleValue, Symbol("paths"), paths) - return new(paths, ) - end -end # type IoK8sApiNetworkingV1beta1HTTPIngressRuleValue - -const _property_types_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue = Dict{Symbol,String}(Symbol("paths")=>"Vector{IoK8sApiNetworkingV1beta1HTTPIngressPath}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1HTTPIngressRuleValue }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1HTTPIngressRuleValue[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1HTTPIngressRuleValue) - o.paths === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1HTTPIngressRuleValue }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1Ingress.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1Ingress.jl deleted file mode 100644 index d353dd35..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1Ingress.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.Ingress -Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. - - IoK8sApiNetworkingV1beta1Ingress(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiNetworkingV1beta1IngressSpec - - status::IoK8sApiNetworkingV1beta1IngressStatus -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1Ingress <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1beta1IngressSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1beta1IngressStatus } - - function IoK8sApiNetworkingV1beta1Ingress(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1Ingress, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1Ingress, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1Ingress, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1Ingress, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1Ingress, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiNetworkingV1beta1Ingress - -const _property_types_IoK8sApiNetworkingV1beta1Ingress = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiNetworkingV1beta1IngressSpec", Symbol("status")=>"IoK8sApiNetworkingV1beta1IngressStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1Ingress }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1Ingress[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1Ingress) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1Ingress }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressBackend.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressBackend.jl deleted file mode 100644 index edb79895..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressBackend.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressBackend -IngressBackend describes all endpoints for a given service and port. - - IoK8sApiNetworkingV1beta1IngressBackend(; - serviceName=nothing, - servicePort=nothing, - ) - - - serviceName::String : Specifies the name of the referenced service. - - servicePort::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressBackend <: OpenAPI.APIModel - serviceName::Union{Nothing, String} = nothing - servicePort::Union{Nothing, Any} = nothing - - function IoK8sApiNetworkingV1beta1IngressBackend(serviceName, servicePort, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressBackend, Symbol("serviceName"), serviceName) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressBackend, Symbol("servicePort"), servicePort) - return new(serviceName, servicePort, ) - end -end # type IoK8sApiNetworkingV1beta1IngressBackend - -const _property_types_IoK8sApiNetworkingV1beta1IngressBackend = Dict{Symbol,String}(Symbol("serviceName")=>"String", Symbol("servicePort")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressBackend }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressBackend[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressBackend) - o.serviceName === nothing && (return false) - o.servicePort === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressBackend }, name::Symbol, val) - if name === Symbol("servicePort") - OpenAPI.validate_param(name, "IoK8sApiNetworkingV1beta1IngressBackend", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressList.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressList.jl deleted file mode 100644 index d190e83d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressList -IngressList is a collection of Ingress. - - IoK8sApiNetworkingV1beta1IngressList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiNetworkingV1beta1Ingress} : Items is the list of Ingress. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1beta1Ingress} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiNetworkingV1beta1IngressList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiNetworkingV1beta1IngressList - -const _property_types_IoK8sApiNetworkingV1beta1IngressList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiNetworkingV1beta1Ingress}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressList[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressRule.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressRule.jl deleted file mode 100644 index 27f9f21b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressRule.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressRule -IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. - - IoK8sApiNetworkingV1beta1IngressRule(; - host=nothing, - http=nothing, - ) - - - host::String : Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the IP in the Spec of the parent Ingress. 2. The `:` delimiter is not respected because ports are not allowed. Currently the port of an Ingress is implicitly :80 for http and :443 for https. Both these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue. - - http::IoK8sApiNetworkingV1beta1HTTPIngressRuleValue -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressRule <: OpenAPI.APIModel - host::Union{Nothing, String} = nothing - http = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1beta1HTTPIngressRuleValue } - - function IoK8sApiNetworkingV1beta1IngressRule(host, http, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressRule, Symbol("host"), host) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressRule, Symbol("http"), http) - return new(host, http, ) - end -end # type IoK8sApiNetworkingV1beta1IngressRule - -const _property_types_IoK8sApiNetworkingV1beta1IngressRule = Dict{Symbol,String}(Symbol("host")=>"String", Symbol("http")=>"IoK8sApiNetworkingV1beta1HTTPIngressRuleValue", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressRule[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressSpec.jl deleted file mode 100644 index 79b8b9af..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressSpec.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressSpec -IngressSpec describes the Ingress the user wishes to exist. - - IoK8sApiNetworkingV1beta1IngressSpec(; - backend=nothing, - rules=nothing, - tls=nothing, - ) - - - backend::IoK8sApiNetworkingV1beta1IngressBackend - - rules::Vector{IoK8sApiNetworkingV1beta1IngressRule} : A list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend. - - tls::Vector{IoK8sApiNetworkingV1beta1IngressTLS} : TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressSpec <: OpenAPI.APIModel - backend = nothing # spec type: Union{ Nothing, IoK8sApiNetworkingV1beta1IngressBackend } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1beta1IngressRule} } - tls::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNetworkingV1beta1IngressTLS} } - - function IoK8sApiNetworkingV1beta1IngressSpec(backend, rules, tls, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressSpec, Symbol("backend"), backend) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressSpec, Symbol("rules"), rules) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressSpec, Symbol("tls"), tls) - return new(backend, rules, tls, ) - end -end # type IoK8sApiNetworkingV1beta1IngressSpec - -const _property_types_IoK8sApiNetworkingV1beta1IngressSpec = Dict{Symbol,String}(Symbol("backend")=>"IoK8sApiNetworkingV1beta1IngressBackend", Symbol("rules")=>"Vector{IoK8sApiNetworkingV1beta1IngressRule}", Symbol("tls")=>"Vector{IoK8sApiNetworkingV1beta1IngressTLS}", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressSpec[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressStatus.jl deleted file mode 100644 index d7773d8a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressStatus -IngressStatus describe the current state of the Ingress. - - IoK8sApiNetworkingV1beta1IngressStatus(; - loadBalancer=nothing, - ) - - - loadBalancer::IoK8sApiCoreV1LoadBalancerStatus -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressStatus <: OpenAPI.APIModel - loadBalancer = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1LoadBalancerStatus } - - function IoK8sApiNetworkingV1beta1IngressStatus(loadBalancer, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressStatus, Symbol("loadBalancer"), loadBalancer) - return new(loadBalancer, ) - end -end # type IoK8sApiNetworkingV1beta1IngressStatus - -const _property_types_IoK8sApiNetworkingV1beta1IngressStatus = Dict{Symbol,String}(Symbol("loadBalancer")=>"IoK8sApiCoreV1LoadBalancerStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressStatus[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressTLS.jl b/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressTLS.jl deleted file mode 100644 index f71467be..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNetworkingV1beta1IngressTLS.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.networking.v1beta1.IngressTLS -IngressTLS describes the transport layer security associated with an Ingress. - - IoK8sApiNetworkingV1beta1IngressTLS(; - hosts=nothing, - secretName=nothing, - ) - - - hosts::Vector{String} : Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. - - secretName::String : SecretName is the name of the secret used to terminate SSL traffic on 443. Field is left optional to allow SSL routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the Host header is used for routing. -""" -Base.@kwdef mutable struct IoK8sApiNetworkingV1beta1IngressTLS <: OpenAPI.APIModel - hosts::Union{Nothing, Vector{String}} = nothing - secretName::Union{Nothing, String} = nothing - - function IoK8sApiNetworkingV1beta1IngressTLS(hosts, secretName, ) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressTLS, Symbol("hosts"), hosts) - OpenAPI.validate_property(IoK8sApiNetworkingV1beta1IngressTLS, Symbol("secretName"), secretName) - return new(hosts, secretName, ) - end -end # type IoK8sApiNetworkingV1beta1IngressTLS - -const _property_types_IoK8sApiNetworkingV1beta1IngressTLS = Dict{Symbol,String}(Symbol("hosts")=>"Vector{String}", Symbol("secretName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiNetworkingV1beta1IngressTLS }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNetworkingV1beta1IngressTLS[name]))} - -function check_required(o::IoK8sApiNetworkingV1beta1IngressTLS) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNetworkingV1beta1IngressTLS }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Overhead.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Overhead.jl deleted file mode 100644 index 806e764a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Overhead.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1alpha1.Overhead -Overhead structure represents the resource overhead associated with running a pod. - - IoK8sApiNodeV1alpha1Overhead(; - podFixed=nothing, - ) - - - podFixed::Dict{String, String} : PodFixed represents the fixed resource overhead associated with running a pod. -""" -Base.@kwdef mutable struct IoK8sApiNodeV1alpha1Overhead <: OpenAPI.APIModel - podFixed::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiNodeV1alpha1Overhead(podFixed, ) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1Overhead, Symbol("podFixed"), podFixed) - return new(podFixed, ) - end -end # type IoK8sApiNodeV1alpha1Overhead - -const _property_types_IoK8sApiNodeV1alpha1Overhead = Dict{Symbol,String}(Symbol("podFixed")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1alpha1Overhead }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1alpha1Overhead[name]))} - -function check_required(o::IoK8sApiNodeV1alpha1Overhead) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1alpha1Overhead }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClass.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClass.jl deleted file mode 100644 index 6fbf034c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClass.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1alpha1.RuntimeClass -RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md - - IoK8sApiNodeV1alpha1RuntimeClass(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiNodeV1alpha1RuntimeClassSpec -""" -Base.@kwdef mutable struct IoK8sApiNodeV1alpha1RuntimeClass <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiNodeV1alpha1RuntimeClassSpec } - - function IoK8sApiNodeV1alpha1RuntimeClass(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClass, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiNodeV1alpha1RuntimeClass - -const _property_types_IoK8sApiNodeV1alpha1RuntimeClass = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiNodeV1alpha1RuntimeClassSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1alpha1RuntimeClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1alpha1RuntimeClass[name]))} - -function check_required(o::IoK8sApiNodeV1alpha1RuntimeClass) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1alpha1RuntimeClass }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassList.jl deleted file mode 100644 index b7b14b8a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1alpha1.RuntimeClassList -RuntimeClassList is a list of RuntimeClass objects. - - IoK8sApiNodeV1alpha1RuntimeClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiNodeV1alpha1RuntimeClass} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiNodeV1alpha1RuntimeClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNodeV1alpha1RuntimeClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiNodeV1alpha1RuntimeClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiNodeV1alpha1RuntimeClassList - -const _property_types_IoK8sApiNodeV1alpha1RuntimeClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiNodeV1alpha1RuntimeClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1alpha1RuntimeClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1alpha1RuntimeClassList[name]))} - -function check_required(o::IoK8sApiNodeV1alpha1RuntimeClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1alpha1RuntimeClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassSpec.jl deleted file mode 100644 index a9158165..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1RuntimeClassSpec.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1alpha1.RuntimeClassSpec -RuntimeClassSpec is a specification of a RuntimeClass. It contains parameters that are required to describe the RuntimeClass to the Container Runtime Interface (CRI) implementation, as well as any other components that need to understand how the pod will be run. The RuntimeClassSpec is immutable. - - IoK8sApiNodeV1alpha1RuntimeClassSpec(; - overhead=nothing, - runtimeHandler=nothing, - scheduling=nothing, - ) - - - overhead::IoK8sApiNodeV1alpha1Overhead - - runtimeHandler::String : RuntimeHandler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called \"runc\" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The RuntimeHandler must conform to the DNS Label (RFC 1123) requirements and is immutable. - - scheduling::IoK8sApiNodeV1alpha1Scheduling -""" -Base.@kwdef mutable struct IoK8sApiNodeV1alpha1RuntimeClassSpec <: OpenAPI.APIModel - overhead = nothing # spec type: Union{ Nothing, IoK8sApiNodeV1alpha1Overhead } - runtimeHandler::Union{Nothing, String} = nothing - scheduling = nothing # spec type: Union{ Nothing, IoK8sApiNodeV1alpha1Scheduling } - - function IoK8sApiNodeV1alpha1RuntimeClassSpec(overhead, runtimeHandler, scheduling, ) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassSpec, Symbol("overhead"), overhead) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassSpec, Symbol("runtimeHandler"), runtimeHandler) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1RuntimeClassSpec, Symbol("scheduling"), scheduling) - return new(overhead, runtimeHandler, scheduling, ) - end -end # type IoK8sApiNodeV1alpha1RuntimeClassSpec - -const _property_types_IoK8sApiNodeV1alpha1RuntimeClassSpec = Dict{Symbol,String}(Symbol("overhead")=>"IoK8sApiNodeV1alpha1Overhead", Symbol("runtimeHandler")=>"String", Symbol("scheduling")=>"IoK8sApiNodeV1alpha1Scheduling", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1alpha1RuntimeClassSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1alpha1RuntimeClassSpec[name]))} - -function check_required(o::IoK8sApiNodeV1alpha1RuntimeClassSpec) - o.runtimeHandler === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1alpha1RuntimeClassSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Scheduling.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Scheduling.jl deleted file mode 100644 index 47bfb11e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1alpha1Scheduling.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1alpha1.Scheduling -Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. - - IoK8sApiNodeV1alpha1Scheduling(; - nodeSelector=nothing, - tolerations=nothing, - ) - - - nodeSelector::Dict{String, String} : nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. - - tolerations::Vector{IoK8sApiCoreV1Toleration} : tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass. -""" -Base.@kwdef mutable struct IoK8sApiNodeV1alpha1Scheduling <: OpenAPI.APIModel - nodeSelector::Union{Nothing, Dict{String, String}} = nothing - tolerations::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Toleration} } - - function IoK8sApiNodeV1alpha1Scheduling(nodeSelector, tolerations, ) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1Scheduling, Symbol("nodeSelector"), nodeSelector) - OpenAPI.validate_property(IoK8sApiNodeV1alpha1Scheduling, Symbol("tolerations"), tolerations) - return new(nodeSelector, tolerations, ) - end -end # type IoK8sApiNodeV1alpha1Scheduling - -const _property_types_IoK8sApiNodeV1alpha1Scheduling = Dict{Symbol,String}(Symbol("nodeSelector")=>"Dict{String, String}", Symbol("tolerations")=>"Vector{IoK8sApiCoreV1Toleration}", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1alpha1Scheduling }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1alpha1Scheduling[name]))} - -function check_required(o::IoK8sApiNodeV1alpha1Scheduling) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1alpha1Scheduling }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Overhead.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Overhead.jl deleted file mode 100644 index 74992ee2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Overhead.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1beta1.Overhead -Overhead structure represents the resource overhead associated with running a pod. - - IoK8sApiNodeV1beta1Overhead(; - podFixed=nothing, - ) - - - podFixed::Dict{String, String} : PodFixed represents the fixed resource overhead associated with running a pod. -""" -Base.@kwdef mutable struct IoK8sApiNodeV1beta1Overhead <: OpenAPI.APIModel - podFixed::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApiNodeV1beta1Overhead(podFixed, ) - OpenAPI.validate_property(IoK8sApiNodeV1beta1Overhead, Symbol("podFixed"), podFixed) - return new(podFixed, ) - end -end # type IoK8sApiNodeV1beta1Overhead - -const _property_types_IoK8sApiNodeV1beta1Overhead = Dict{Symbol,String}(Symbol("podFixed")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1beta1Overhead }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1beta1Overhead[name]))} - -function check_required(o::IoK8sApiNodeV1beta1Overhead) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1beta1Overhead }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClass.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClass.jl deleted file mode 100644 index d7400a65..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClass.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1beta1.RuntimeClass -RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md - - IoK8sApiNodeV1beta1RuntimeClass(; - apiVersion=nothing, - handler=nothing, - kind=nothing, - metadata=nothing, - overhead=nothing, - scheduling=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - handler::String : Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called \"runc\" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must conform to the DNS Label (RFC 1123) requirements, and is immutable. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - overhead::IoK8sApiNodeV1beta1Overhead - - scheduling::IoK8sApiNodeV1beta1Scheduling -""" -Base.@kwdef mutable struct IoK8sApiNodeV1beta1RuntimeClass <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - handler::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - overhead = nothing # spec type: Union{ Nothing, IoK8sApiNodeV1beta1Overhead } - scheduling = nothing # spec type: Union{ Nothing, IoK8sApiNodeV1beta1Scheduling } - - function IoK8sApiNodeV1beta1RuntimeClass(apiVersion, handler, kind, metadata, overhead, scheduling, ) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("handler"), handler) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("overhead"), overhead) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClass, Symbol("scheduling"), scheduling) - return new(apiVersion, handler, kind, metadata, overhead, scheduling, ) - end -end # type IoK8sApiNodeV1beta1RuntimeClass - -const _property_types_IoK8sApiNodeV1beta1RuntimeClass = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("handler")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("overhead")=>"IoK8sApiNodeV1beta1Overhead", Symbol("scheduling")=>"IoK8sApiNodeV1beta1Scheduling", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1beta1RuntimeClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1beta1RuntimeClass[name]))} - -function check_required(o::IoK8sApiNodeV1beta1RuntimeClass) - o.handler === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1beta1RuntimeClass }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClassList.jl deleted file mode 100644 index 83e0ee88..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1RuntimeClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1beta1.RuntimeClassList -RuntimeClassList is a list of RuntimeClass objects. - - IoK8sApiNodeV1beta1RuntimeClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiNodeV1beta1RuntimeClass} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiNodeV1beta1RuntimeClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiNodeV1beta1RuntimeClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiNodeV1beta1RuntimeClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiNodeV1beta1RuntimeClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiNodeV1beta1RuntimeClassList - -const _property_types_IoK8sApiNodeV1beta1RuntimeClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiNodeV1beta1RuntimeClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1beta1RuntimeClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1beta1RuntimeClassList[name]))} - -function check_required(o::IoK8sApiNodeV1beta1RuntimeClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1beta1RuntimeClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Scheduling.jl b/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Scheduling.jl deleted file mode 100644 index 2d249e5c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiNodeV1beta1Scheduling.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.node.v1beta1.Scheduling -Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. - - IoK8sApiNodeV1beta1Scheduling(; - nodeSelector=nothing, - tolerations=nothing, - ) - - - nodeSelector::Dict{String, String} : nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. - - tolerations::Vector{IoK8sApiCoreV1Toleration} : tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass. -""" -Base.@kwdef mutable struct IoK8sApiNodeV1beta1Scheduling <: OpenAPI.APIModel - nodeSelector::Union{Nothing, Dict{String, String}} = nothing - tolerations::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Toleration} } - - function IoK8sApiNodeV1beta1Scheduling(nodeSelector, tolerations, ) - OpenAPI.validate_property(IoK8sApiNodeV1beta1Scheduling, Symbol("nodeSelector"), nodeSelector) - OpenAPI.validate_property(IoK8sApiNodeV1beta1Scheduling, Symbol("tolerations"), tolerations) - return new(nodeSelector, tolerations, ) - end -end # type IoK8sApiNodeV1beta1Scheduling - -const _property_types_IoK8sApiNodeV1beta1Scheduling = Dict{Symbol,String}(Symbol("nodeSelector")=>"Dict{String, String}", Symbol("tolerations")=>"Vector{IoK8sApiCoreV1Toleration}", ) -OpenAPI.property_type(::Type{ IoK8sApiNodeV1beta1Scheduling }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiNodeV1beta1Scheduling[name]))} - -function check_required(o::IoK8sApiNodeV1beta1Scheduling) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiNodeV1beta1Scheduling }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedCSIDriver.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedCSIDriver.jl deleted file mode 100644 index c01b5bc1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedCSIDriver.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.AllowedCSIDriver -AllowedCSIDriver represents a single inline CSI Driver that is allowed to be used. - - IoK8sApiPolicyV1beta1AllowedCSIDriver(; - name=nothing, - ) - - - name::String : Name is the registered name of the CSI driver -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1AllowedCSIDriver <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1AllowedCSIDriver(name, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1AllowedCSIDriver, Symbol("name"), name) - return new(name, ) - end -end # type IoK8sApiPolicyV1beta1AllowedCSIDriver - -const _property_types_IoK8sApiPolicyV1beta1AllowedCSIDriver = Dict{Symbol,String}(Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1AllowedCSIDriver }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1AllowedCSIDriver[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1AllowedCSIDriver) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1AllowedCSIDriver }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedFlexVolume.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedFlexVolume.jl deleted file mode 100644 index 8f830cb9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedFlexVolume.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.AllowedFlexVolume -AllowedFlexVolume represents a single Flexvolume that is allowed to be used. - - IoK8sApiPolicyV1beta1AllowedFlexVolume(; - driver=nothing, - ) - - - driver::String : driver is the name of the Flexvolume driver. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1AllowedFlexVolume <: OpenAPI.APIModel - driver::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1AllowedFlexVolume(driver, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1AllowedFlexVolume, Symbol("driver"), driver) - return new(driver, ) - end -end # type IoK8sApiPolicyV1beta1AllowedFlexVolume - -const _property_types_IoK8sApiPolicyV1beta1AllowedFlexVolume = Dict{Symbol,String}(Symbol("driver")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1AllowedFlexVolume }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1AllowedFlexVolume[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1AllowedFlexVolume) - o.driver === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1AllowedFlexVolume }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedHostPath.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedHostPath.jl deleted file mode 100644 index 22c197d1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1AllowedHostPath.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.AllowedHostPath -AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. - - IoK8sApiPolicyV1beta1AllowedHostPath(; - pathPrefix=nothing, - readOnly=nothing, - ) - - - pathPrefix::String : pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` - - readOnly::Bool : when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1AllowedHostPath <: OpenAPI.APIModel - pathPrefix::Union{Nothing, String} = nothing - readOnly::Union{Nothing, Bool} = nothing - - function IoK8sApiPolicyV1beta1AllowedHostPath(pathPrefix, readOnly, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1AllowedHostPath, Symbol("pathPrefix"), pathPrefix) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1AllowedHostPath, Symbol("readOnly"), readOnly) - return new(pathPrefix, readOnly, ) - end -end # type IoK8sApiPolicyV1beta1AllowedHostPath - -const _property_types_IoK8sApiPolicyV1beta1AllowedHostPath = Dict{Symbol,String}(Symbol("pathPrefix")=>"String", Symbol("readOnly")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1AllowedHostPath }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1AllowedHostPath[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1AllowedHostPath) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1AllowedHostPath }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1Eviction.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1Eviction.jl deleted file mode 100644 index a591272b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1Eviction.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.Eviction -Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods/<pod name>/evictions. - - IoK8sApiPolicyV1beta1Eviction(; - apiVersion=nothing, - deleteOptions=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - deleteOptions::IoK8sApimachineryPkgApisMetaV1DeleteOptions - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1Eviction <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - deleteOptions = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1DeleteOptions } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - - function IoK8sApiPolicyV1beta1Eviction(apiVersion, deleteOptions, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1Eviction, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1Eviction, Symbol("deleteOptions"), deleteOptions) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1Eviction, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1Eviction, Symbol("metadata"), metadata) - return new(apiVersion, deleteOptions, kind, metadata, ) - end -end # type IoK8sApiPolicyV1beta1Eviction - -const _property_types_IoK8sApiPolicyV1beta1Eviction = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("deleteOptions")=>"IoK8sApimachineryPkgApisMetaV1DeleteOptions", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1Eviction }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1Eviction[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1Eviction) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1Eviction }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1FSGroupStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1FSGroupStrategyOptions.jl deleted file mode 100644 index e5124485..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1FSGroupStrategyOptions.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.FSGroupStrategyOptions -FSGroupStrategyOptions defines the strategy type and options used to create the strategy. - - IoK8sApiPolicyV1beta1FSGroupStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiPolicyV1beta1IDRange} : ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate what FSGroup is used in the SecurityContext. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1FSGroupStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1FSGroupStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1FSGroupStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1FSGroupStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiPolicyV1beta1FSGroupStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1FSGroupStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiPolicyV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1FSGroupStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1FSGroupStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1FSGroupStrategyOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1FSGroupStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1HostPortRange.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1HostPortRange.jl deleted file mode 100644 index 99c76382..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1HostPortRange.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.HostPortRange -HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. - - IoK8sApiPolicyV1beta1HostPortRange(; - max=nothing, - min=nothing, - ) - - - max::Int64 : max is the end of the range, inclusive. - - min::Int64 : min is the start of the range, inclusive. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1HostPortRange <: OpenAPI.APIModel - max::Union{Nothing, Int64} = nothing - min::Union{Nothing, Int64} = nothing - - function IoK8sApiPolicyV1beta1HostPortRange(max, min, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1HostPortRange, Symbol("max"), max) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1HostPortRange, Symbol("min"), min) - return new(max, min, ) - end -end # type IoK8sApiPolicyV1beta1HostPortRange - -const _property_types_IoK8sApiPolicyV1beta1HostPortRange = Dict{Symbol,String}(Symbol("max")=>"Int64", Symbol("min")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1HostPortRange }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1HostPortRange[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1HostPortRange) - o.max === nothing && (return false) - o.min === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1HostPortRange }, name::Symbol, val) - if name === Symbol("max") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1HostPortRange", :format, val, "int32") - end - if name === Symbol("min") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1HostPortRange", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1IDRange.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1IDRange.jl deleted file mode 100644 index 3e722019..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1IDRange.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.IDRange -IDRange provides a min/max of an allowed range of IDs. - - IoK8sApiPolicyV1beta1IDRange(; - max=nothing, - min=nothing, - ) - - - max::Int64 : max is the end of the range, inclusive. - - min::Int64 : min is the start of the range, inclusive. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1IDRange <: OpenAPI.APIModel - max::Union{Nothing, Int64} = nothing - min::Union{Nothing, Int64} = nothing - - function IoK8sApiPolicyV1beta1IDRange(max, min, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1IDRange, Symbol("max"), max) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1IDRange, Symbol("min"), min) - return new(max, min, ) - end -end # type IoK8sApiPolicyV1beta1IDRange - -const _property_types_IoK8sApiPolicyV1beta1IDRange = Dict{Symbol,String}(Symbol("max")=>"Int64", Symbol("min")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1IDRange }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1IDRange[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1IDRange) - o.max === nothing && (return false) - o.min === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1IDRange }, name::Symbol, val) - if name === Symbol("max") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1IDRange", :format, val, "int64") - end - if name === Symbol("min") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1IDRange", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudget.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudget.jl deleted file mode 100644 index 929bf386..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudget.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodDisruptionBudget -PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods - - IoK8sApiPolicyV1beta1PodDisruptionBudget(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec - - status::IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodDisruptionBudget <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus } - - function IoK8sApiPolicyV1beta1PodDisruptionBudget(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudget, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudget, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudget, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudget, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudget, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiPolicyV1beta1PodDisruptionBudget - -const _property_types_IoK8sApiPolicyV1beta1PodDisruptionBudget = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec", Symbol("status")=>"IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudget }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodDisruptionBudget[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodDisruptionBudget) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudget }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetList.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetList.jl deleted file mode 100644 index ea87a499..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodDisruptionBudgetList -PodDisruptionBudgetList is a collection of PodDisruptionBudgets. - - IoK8sApiPolicyV1beta1PodDisruptionBudgetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiPolicyV1beta1PodDisruptionBudget} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodDisruptionBudgetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1PodDisruptionBudget} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiPolicyV1beta1PodDisruptionBudgetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiPolicyV1beta1PodDisruptionBudgetList - -const _property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiPolicyV1beta1PodDisruptionBudget}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetList[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodDisruptionBudgetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec.jl deleted file mode 100644 index e88e765c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec -PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. - - IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec(; - maxUnavailable=nothing, - minAvailable=nothing, - selector=nothing, - ) - - - maxUnavailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - minAvailable::Any : IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec <: OpenAPI.APIModel - maxUnavailable::Union{Nothing, Any} = nothing - minAvailable::Union{Nothing, Any} = nothing - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - - function IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec(maxUnavailable, minAvailable, selector, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec, Symbol("maxUnavailable"), maxUnavailable) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec, Symbol("minAvailable"), minAvailable) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec, Symbol("selector"), selector) - return new(maxUnavailable, minAvailable, selector, ) - end -end # type IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec - -const _property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec = Dict{Symbol,String}(Symbol("maxUnavailable")=>"Any", Symbol("minAvailable")=>"Any", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec }, name::Symbol, val) - if name === Symbol("maxUnavailable") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec", :format, val, "int-or-string") - end - if name === Symbol("minAvailable") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec", :format, val, "int-or-string") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus.jl deleted file mode 100644 index 923e38a2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus -PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. - - IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus(; - currentHealthy=nothing, - desiredHealthy=nothing, - disruptedPods=nothing, - disruptionsAllowed=nothing, - expectedPods=nothing, - observedGeneration=nothing, - ) - - - currentHealthy::Int64 : current number of healthy pods - - desiredHealthy::Int64 : minimum desired number of healthy pods - - disruptedPods::Dict{String, ZonedDateTime} : DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions. - - disruptionsAllowed::Int64 : Number of pod disruptions that are currently allowed. - - expectedPods::Int64 : total number of pods counted by this disruption budget - - observedGeneration::Int64 : Most recent generation observed when updating this PDB status. PodDisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus <: OpenAPI.APIModel - currentHealthy::Union{Nothing, Int64} = nothing - desiredHealthy::Union{Nothing, Int64} = nothing - disruptedPods::Union{Nothing, Dict{String, ZonedDateTime}} = nothing - disruptionsAllowed::Union{Nothing, Int64} = nothing - expectedPods::Union{Nothing, Int64} = nothing - observedGeneration::Union{Nothing, Int64} = nothing - - function IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus(currentHealthy, desiredHealthy, disruptedPods, disruptionsAllowed, expectedPods, observedGeneration, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("currentHealthy"), currentHealthy) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("desiredHealthy"), desiredHealthy) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("disruptedPods"), disruptedPods) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("disruptionsAllowed"), disruptionsAllowed) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("expectedPods"), expectedPods) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus, Symbol("observedGeneration"), observedGeneration) - return new(currentHealthy, desiredHealthy, disruptedPods, disruptionsAllowed, expectedPods, observedGeneration, ) - end -end # type IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus - -const _property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus = Dict{Symbol,String}(Symbol("currentHealthy")=>"Int64", Symbol("desiredHealthy")=>"Int64", Symbol("disruptedPods")=>"Dict{String, ZonedDateTime}", Symbol("disruptionsAllowed")=>"Int64", Symbol("expectedPods")=>"Int64", Symbol("observedGeneration")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus) - o.currentHealthy === nothing && (return false) - o.desiredHealthy === nothing && (return false) - o.disruptionsAllowed === nothing && (return false) - o.expectedPods === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus }, name::Symbol, val) - if name === Symbol("currentHealthy") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", :format, val, "int32") - end - if name === Symbol("desiredHealthy") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", :format, val, "int32") - end - if name === Symbol("disruptionsAllowed") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", :format, val, "int32") - end - if name === Symbol("expectedPods") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", :format, val, "int32") - end - if name === Symbol("observedGeneration") - OpenAPI.validate_param(name, "IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicy.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicy.jl deleted file mode 100644 index 36a7b95b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicy.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodSecurityPolicy -PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. - - IoK8sApiPolicyV1beta1PodSecurityPolicy(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiPolicyV1beta1PodSecurityPolicySpec -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodSecurityPolicy <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1PodSecurityPolicySpec } - - function IoK8sApiPolicyV1beta1PodSecurityPolicy(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicy, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicy, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicy, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicy, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiPolicyV1beta1PodSecurityPolicy - -const _property_types_IoK8sApiPolicyV1beta1PodSecurityPolicy = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiPolicyV1beta1PodSecurityPolicySpec", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicy }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodSecurityPolicy[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodSecurityPolicy) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicy }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicyList.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicyList.jl deleted file mode 100644 index 0005a6fb..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicyList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodSecurityPolicyList -PodSecurityPolicyList is a list of PodSecurityPolicy objects. - - IoK8sApiPolicyV1beta1PodSecurityPolicyList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiPolicyV1beta1PodSecurityPolicy} : items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodSecurityPolicyList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1PodSecurityPolicy} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiPolicyV1beta1PodSecurityPolicyList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicyList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicyList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicyList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicyList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiPolicyV1beta1PodSecurityPolicyList - -const _property_types_IoK8sApiPolicyV1beta1PodSecurityPolicyList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiPolicyV1beta1PodSecurityPolicy}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicyList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodSecurityPolicyList[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodSecurityPolicyList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicyList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicySpec.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicySpec.jl deleted file mode 100644 index 94c1a453..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1PodSecurityPolicySpec.jl +++ /dev/null @@ -1,127 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.PodSecurityPolicySpec -PodSecurityPolicySpec defines the policy enforced. - - IoK8sApiPolicyV1beta1PodSecurityPolicySpec(; - allowPrivilegeEscalation=nothing, - allowedCSIDrivers=nothing, - allowedCapabilities=nothing, - allowedFlexVolumes=nothing, - allowedHostPaths=nothing, - allowedProcMountTypes=nothing, - allowedUnsafeSysctls=nothing, - defaultAddCapabilities=nothing, - defaultAllowPrivilegeEscalation=nothing, - forbiddenSysctls=nothing, - fsGroup=nothing, - hostIPC=nothing, - hostNetwork=nothing, - hostPID=nothing, - hostPorts=nothing, - privileged=nothing, - readOnlyRootFilesystem=nothing, - requiredDropCapabilities=nothing, - runAsGroup=nothing, - runAsUser=nothing, - runtimeClass=nothing, - seLinux=nothing, - supplementalGroups=nothing, - volumes=nothing, - ) - - - allowPrivilegeEscalation::Bool : allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. - - allowedCSIDrivers::Vector{IoK8sApiPolicyV1beta1AllowedCSIDriver} : AllowedCSIDrivers is a whitelist of inline CSI drivers that must be explicitly set to be embedded within a pod spec. An empty value indicates that any CSI driver can be used for inline ephemeral volumes. This is an alpha field, and is only honored if the API server enables the CSIInlineVolume feature gate. - - allowedCapabilities::Vector{String} : allowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field may be added at the pod author's discretion. You must not list a capability in both allowedCapabilities and requiredDropCapabilities. - - allowedFlexVolumes::Vector{IoK8sApiPolicyV1beta1AllowedFlexVolume} : allowedFlexVolumes is a whitelist of allowed Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the \"volumes\" field. - - allowedHostPaths::Vector{IoK8sApiPolicyV1beta1AllowedHostPath} : allowedHostPaths is a white list of allowed host paths. Empty indicates that all host paths may be used. - - allowedProcMountTypes::Vector{String} : AllowedProcMountTypes is a whitelist of allowed ProcMountTypes. Empty or nil indicates that only the DefaultProcMountType may be used. This requires the ProcMountType feature flag to be enabled. - - allowedUnsafeSysctls::Vector{String} : allowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection. Examples: e.g. \"foo/*\" allows \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" allows \"foo.bar\", \"foo.baz\", etc. - - defaultAddCapabilities::Vector{String} : defaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capability in both defaultAddCapabilities and requiredDropCapabilities. Capabilities added here are implicitly allowed, and need not be included in the allowedCapabilities list. - - defaultAllowPrivilegeEscalation::Bool : defaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. - - forbiddenSysctls::Vector{String} : forbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. Examples: e.g. \"foo/*\" forbids \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" forbids \"foo.bar\", \"foo.baz\", etc. - - fsGroup::IoK8sApiPolicyV1beta1FSGroupStrategyOptions - - hostIPC::Bool : hostIPC determines if the policy allows the use of HostIPC in the pod spec. - - hostNetwork::Bool : hostNetwork determines if the policy allows the use of HostNetwork in the pod spec. - - hostPID::Bool : hostPID determines if the policy allows the use of HostPID in the pod spec. - - hostPorts::Vector{IoK8sApiPolicyV1beta1HostPortRange} : hostPorts determines which host port ranges are allowed to be exposed. - - privileged::Bool : privileged determines if a pod can request to be run as privileged. - - readOnlyRootFilesystem::Bool : readOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the PSP should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. - - requiredDropCapabilities::Vector{String} : requiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. - - runAsGroup::IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions - - runAsUser::IoK8sApiPolicyV1beta1RunAsUserStrategyOptions - - runtimeClass::IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions - - seLinux::IoK8sApiPolicyV1beta1SELinuxStrategyOptions - - supplementalGroups::IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions - - volumes::Vector{String} : volumes is a white list of allowed volume plugins. Empty indicates that no volumes may be used. To allow all volumes you may use '*'. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1PodSecurityPolicySpec <: OpenAPI.APIModel - allowPrivilegeEscalation::Union{Nothing, Bool} = nothing - allowedCSIDrivers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1AllowedCSIDriver} } - allowedCapabilities::Union{Nothing, Vector{String}} = nothing - allowedFlexVolumes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1AllowedFlexVolume} } - allowedHostPaths::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1AllowedHostPath} } - allowedProcMountTypes::Union{Nothing, Vector{String}} = nothing - allowedUnsafeSysctls::Union{Nothing, Vector{String}} = nothing - defaultAddCapabilities::Union{Nothing, Vector{String}} = nothing - defaultAllowPrivilegeEscalation::Union{Nothing, Bool} = nothing - forbiddenSysctls::Union{Nothing, Vector{String}} = nothing - fsGroup = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1FSGroupStrategyOptions } - hostIPC::Union{Nothing, Bool} = nothing - hostNetwork::Union{Nothing, Bool} = nothing - hostPID::Union{Nothing, Bool} = nothing - hostPorts::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1HostPortRange} } - privileged::Union{Nothing, Bool} = nothing - readOnlyRootFilesystem::Union{Nothing, Bool} = nothing - requiredDropCapabilities::Union{Nothing, Vector{String}} = nothing - runAsGroup = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions } - runAsUser = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1RunAsUserStrategyOptions } - runtimeClass = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions } - seLinux = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1SELinuxStrategyOptions } - supplementalGroups = nothing # spec type: Union{ Nothing, IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions } - volumes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiPolicyV1beta1PodSecurityPolicySpec(allowPrivilegeEscalation, allowedCSIDrivers, allowedCapabilities, allowedFlexVolumes, allowedHostPaths, allowedProcMountTypes, allowedUnsafeSysctls, defaultAddCapabilities, defaultAllowPrivilegeEscalation, forbiddenSysctls, fsGroup, hostIPC, hostNetwork, hostPID, hostPorts, privileged, readOnlyRootFilesystem, requiredDropCapabilities, runAsGroup, runAsUser, runtimeClass, seLinux, supplementalGroups, volumes, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowPrivilegeEscalation"), allowPrivilegeEscalation) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedCSIDrivers"), allowedCSIDrivers) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedCapabilities"), allowedCapabilities) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedFlexVolumes"), allowedFlexVolumes) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedHostPaths"), allowedHostPaths) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedProcMountTypes"), allowedProcMountTypes) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("allowedUnsafeSysctls"), allowedUnsafeSysctls) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("defaultAddCapabilities"), defaultAddCapabilities) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("defaultAllowPrivilegeEscalation"), defaultAllowPrivilegeEscalation) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("forbiddenSysctls"), forbiddenSysctls) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("fsGroup"), fsGroup) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("hostIPC"), hostIPC) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("hostNetwork"), hostNetwork) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("hostPID"), hostPID) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("hostPorts"), hostPorts) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("privileged"), privileged) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("readOnlyRootFilesystem"), readOnlyRootFilesystem) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("requiredDropCapabilities"), requiredDropCapabilities) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("runAsGroup"), runAsGroup) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("runAsUser"), runAsUser) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("runtimeClass"), runtimeClass) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("seLinux"), seLinux) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("supplementalGroups"), supplementalGroups) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1PodSecurityPolicySpec, Symbol("volumes"), volumes) - return new(allowPrivilegeEscalation, allowedCSIDrivers, allowedCapabilities, allowedFlexVolumes, allowedHostPaths, allowedProcMountTypes, allowedUnsafeSysctls, defaultAddCapabilities, defaultAllowPrivilegeEscalation, forbiddenSysctls, fsGroup, hostIPC, hostNetwork, hostPID, hostPorts, privileged, readOnlyRootFilesystem, requiredDropCapabilities, runAsGroup, runAsUser, runtimeClass, seLinux, supplementalGroups, volumes, ) - end -end # type IoK8sApiPolicyV1beta1PodSecurityPolicySpec - -const _property_types_IoK8sApiPolicyV1beta1PodSecurityPolicySpec = Dict{Symbol,String}(Symbol("allowPrivilegeEscalation")=>"Bool", Symbol("allowedCSIDrivers")=>"Vector{IoK8sApiPolicyV1beta1AllowedCSIDriver}", Symbol("allowedCapabilities")=>"Vector{String}", Symbol("allowedFlexVolumes")=>"Vector{IoK8sApiPolicyV1beta1AllowedFlexVolume}", Symbol("allowedHostPaths")=>"Vector{IoK8sApiPolicyV1beta1AllowedHostPath}", Symbol("allowedProcMountTypes")=>"Vector{String}", Symbol("allowedUnsafeSysctls")=>"Vector{String}", Symbol("defaultAddCapabilities")=>"Vector{String}", Symbol("defaultAllowPrivilegeEscalation")=>"Bool", Symbol("forbiddenSysctls")=>"Vector{String}", Symbol("fsGroup")=>"IoK8sApiPolicyV1beta1FSGroupStrategyOptions", Symbol("hostIPC")=>"Bool", Symbol("hostNetwork")=>"Bool", Symbol("hostPID")=>"Bool", Symbol("hostPorts")=>"Vector{IoK8sApiPolicyV1beta1HostPortRange}", Symbol("privileged")=>"Bool", Symbol("readOnlyRootFilesystem")=>"Bool", Symbol("requiredDropCapabilities")=>"Vector{String}", Symbol("runAsGroup")=>"IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions", Symbol("runAsUser")=>"IoK8sApiPolicyV1beta1RunAsUserStrategyOptions", Symbol("runtimeClass")=>"IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions", Symbol("seLinux")=>"IoK8sApiPolicyV1beta1SELinuxStrategyOptions", Symbol("supplementalGroups")=>"IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions", Symbol("volumes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicySpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1PodSecurityPolicySpec[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1PodSecurityPolicySpec) - o.fsGroup === nothing && (return false) - o.runAsUser === nothing && (return false) - o.seLinux === nothing && (return false) - o.supplementalGroups === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1PodSecurityPolicySpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions.jl deleted file mode 100644 index 8ac3e85f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.RunAsGroupStrategyOptions -RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. - - IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiPolicyV1beta1IDRange} : ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate the allowable RunAsGroup values that may be set. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiPolicyV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions.jl deleted file mode 100644 index 0d43bf33..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.RunAsUserStrategyOptions -RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. - - IoK8sApiPolicyV1beta1RunAsUserStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiPolicyV1beta1IDRange} : ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate the allowable RunAsUser values that may be set. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1RunAsUserStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1RunAsUserStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RunAsUserStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RunAsUserStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiPolicyV1beta1RunAsUserStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiPolicyV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1RunAsUserStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1RunAsUserStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1RunAsUserStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1RunAsUserStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions.jl deleted file mode 100644 index ed274cc7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.RuntimeClassStrategyOptions -RuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod. - - IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions(; - allowedRuntimeClassNames=nothing, - defaultRuntimeClassName=nothing, - ) - - - allowedRuntimeClassNames::Vector{String} : allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of \"*\" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. - - defaultRuntimeClassName::String : defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions <: OpenAPI.APIModel - allowedRuntimeClassNames::Union{Nothing, Vector{String}} = nothing - defaultRuntimeClassName::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions(allowedRuntimeClassNames, defaultRuntimeClassName, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions, Symbol("allowedRuntimeClassNames"), allowedRuntimeClassNames) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions, Symbol("defaultRuntimeClassName"), defaultRuntimeClassName) - return new(allowedRuntimeClassNames, defaultRuntimeClassName, ) - end -end # type IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions = Dict{Symbol,String}(Symbol("allowedRuntimeClassNames")=>"Vector{String}", Symbol("defaultRuntimeClassName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions) - o.allowedRuntimeClassNames === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SELinuxStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SELinuxStrategyOptions.jl deleted file mode 100644 index 10d6ba6f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SELinuxStrategyOptions.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.SELinuxStrategyOptions -SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. - - IoK8sApiPolicyV1beta1SELinuxStrategyOptions(; - rule=nothing, - seLinuxOptions=nothing, - ) - - - rule::String : rule is the strategy that will dictate the allowable labels that may be set. - - seLinuxOptions::IoK8sApiCoreV1SELinuxOptions -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1SELinuxStrategyOptions <: OpenAPI.APIModel - rule::Union{Nothing, String} = nothing - seLinuxOptions = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1SELinuxOptions } - - function IoK8sApiPolicyV1beta1SELinuxStrategyOptions(rule, seLinuxOptions, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1SELinuxStrategyOptions, Symbol("rule"), rule) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1SELinuxStrategyOptions, Symbol("seLinuxOptions"), seLinuxOptions) - return new(rule, seLinuxOptions, ) - end -end # type IoK8sApiPolicyV1beta1SELinuxStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1SELinuxStrategyOptions = Dict{Symbol,String}(Symbol("rule")=>"String", Symbol("seLinuxOptions")=>"IoK8sApiCoreV1SELinuxOptions", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1SELinuxStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1SELinuxStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1SELinuxStrategyOptions) - o.rule === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1SELinuxStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions.jl b/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions.jl deleted file mode 100644 index a15549ec..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.policy.v1beta1.SupplementalGroupsStrategyOptions -SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. - - IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions(; - ranges=nothing, - rule=nothing, - ) - - - ranges::Vector{IoK8sApiPolicyV1beta1IDRange} : ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. - - rule::String : rule is the strategy that will dictate what supplemental groups is used in the SecurityContext. -""" -Base.@kwdef mutable struct IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions <: OpenAPI.APIModel - ranges::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiPolicyV1beta1IDRange} } - rule::Union{Nothing, String} = nothing - - function IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions(ranges, rule, ) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions, Symbol("ranges"), ranges) - OpenAPI.validate_property(IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions, Symbol("rule"), rule) - return new(ranges, rule, ) - end -end # type IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions - -const _property_types_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions = Dict{Symbol,String}(Symbol("ranges")=>"Vector{IoK8sApiPolicyV1beta1IDRange}", Symbol("rule")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions[name]))} - -function check_required(o::IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1AggregationRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1AggregationRule.jl deleted file mode 100644 index fe3b51d7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1AggregationRule.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.AggregationRule -AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole - - IoK8sApiRbacV1AggregationRule(; - clusterRoleSelectors=nothing, - ) - - - clusterRoleSelectors::Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} : ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added -""" -Base.@kwdef mutable struct IoK8sApiRbacV1AggregationRule <: OpenAPI.APIModel - clusterRoleSelectors::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} } - - function IoK8sApiRbacV1AggregationRule(clusterRoleSelectors, ) - OpenAPI.validate_property(IoK8sApiRbacV1AggregationRule, Symbol("clusterRoleSelectors"), clusterRoleSelectors) - return new(clusterRoleSelectors, ) - end -end # type IoK8sApiRbacV1AggregationRule - -const _property_types_IoK8sApiRbacV1AggregationRule = Dict{Symbol,String}(Symbol("clusterRoleSelectors")=>"Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1AggregationRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1AggregationRule[name]))} - -function check_required(o::IoK8sApiRbacV1AggregationRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1AggregationRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRole.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRole.jl deleted file mode 100644 index e0d1a44e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRole.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.ClusterRole -ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. - - IoK8sApiRbacV1ClusterRole(; - aggregationRule=nothing, - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - aggregationRule::IoK8sApiRbacV1AggregationRule - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1PolicyRule} : Rules holds all the PolicyRules for this ClusterRole -""" -Base.@kwdef mutable struct IoK8sApiRbacV1ClusterRole <: OpenAPI.APIModel - aggregationRule = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1AggregationRule } - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1PolicyRule} } - - function IoK8sApiRbacV1ClusterRole(aggregationRule, apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRole, Symbol("aggregationRule"), aggregationRule) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRole, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRole, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRole, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRole, Symbol("rules"), rules) - return new(aggregationRule, apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1ClusterRole - -const _property_types_IoK8sApiRbacV1ClusterRole = Dict{Symbol,String}(Symbol("aggregationRule")=>"IoK8sApiRbacV1AggregationRule", Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1ClusterRole }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1ClusterRole[name]))} - -function check_required(o::IoK8sApiRbacV1ClusterRole) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1ClusterRole }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBinding.jl deleted file mode 100644 index c932349b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.ClusterRoleBinding -ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. - - IoK8sApiRbacV1ClusterRoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1RoleRef - - subjects::Vector{IoK8sApiRbacV1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1ClusterRoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1Subject} } - - function IoK8sApiRbacV1ClusterRoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1ClusterRoleBinding - -const _property_types_IoK8sApiRbacV1ClusterRoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1ClusterRoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1ClusterRoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1ClusterRoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1ClusterRoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBindingList.jl deleted file mode 100644 index 7e1696d4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.ClusterRoleBindingList -ClusterRoleBindingList is a collection of ClusterRoleBindings - - IoK8sApiRbacV1ClusterRoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1ClusterRoleBinding} : Items is a list of ClusterRoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1ClusterRoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1ClusterRoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1ClusterRoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1ClusterRoleBindingList - -const _property_types_IoK8sApiRbacV1ClusterRoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1ClusterRoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1ClusterRoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1ClusterRoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1ClusterRoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1ClusterRoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleList.jl deleted file mode 100644 index b45498b5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1ClusterRoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.ClusterRoleList -ClusterRoleList is a collection of ClusterRoles - - IoK8sApiRbacV1ClusterRoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1ClusterRole} : Items is a list of ClusterRoles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1ClusterRoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1ClusterRole} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1ClusterRoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1ClusterRoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1ClusterRoleList - -const _property_types_IoK8sApiRbacV1ClusterRoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1ClusterRole}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1ClusterRoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1ClusterRoleList[name]))} - -function check_required(o::IoK8sApiRbacV1ClusterRoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1ClusterRoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1PolicyRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1PolicyRule.jl deleted file mode 100644 index 84bf12dc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1PolicyRule.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.PolicyRule -PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. - - IoK8sApiRbacV1PolicyRule(; - apiGroups=nothing, - nonResourceURLs=nothing, - resourceNames=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. - - nonResourceURLs::Vector{String} : NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both. - - resourceNames::Vector{String} : ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. - - resources::Vector{String} : Resources is a list of resources this rule applies to. ResourceAll represents all resources. - - verbs::Vector{String} : Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1PolicyRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - resourceNames::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiRbacV1PolicyRule(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiRbacV1PolicyRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiRbacV1PolicyRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiRbacV1PolicyRule, Symbol("resourceNames"), resourceNames) - OpenAPI.validate_property(IoK8sApiRbacV1PolicyRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiRbacV1PolicyRule, Symbol("verbs"), verbs) - return new(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - end -end # type IoK8sApiRbacV1PolicyRule - -const _property_types_IoK8sApiRbacV1PolicyRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("nonResourceURLs")=>"Vector{String}", Symbol("resourceNames")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1PolicyRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1PolicyRule[name]))} - -function check_required(o::IoK8sApiRbacV1PolicyRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1PolicyRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1Role.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1Role.jl deleted file mode 100644 index 6b1f7836..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1Role.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.Role -Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. - - IoK8sApiRbacV1Role(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1PolicyRule} : Rules holds all the PolicyRules for this Role -""" -Base.@kwdef mutable struct IoK8sApiRbacV1Role <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1PolicyRule} } - - function IoK8sApiRbacV1Role(apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1Role, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1Role, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1Role, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1Role, Symbol("rules"), rules) - return new(apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1Role - -const _property_types_IoK8sApiRbacV1Role = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1Role }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1Role[name]))} - -function check_required(o::IoK8sApiRbacV1Role) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1Role }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBinding.jl deleted file mode 100644 index 0a20beb3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.RoleBinding -RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. - - IoK8sApiRbacV1RoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1RoleRef - - subjects::Vector{IoK8sApiRbacV1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1RoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1Subject} } - - function IoK8sApiRbacV1RoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1RoleBinding - -const _property_types_IoK8sApiRbacV1RoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1RoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1RoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1RoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1RoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBindingList.jl deleted file mode 100644 index a461c365..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.RoleBindingList -RoleBindingList is a collection of RoleBindings - - IoK8sApiRbacV1RoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1RoleBinding} : Items is a list of RoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1RoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1RoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1RoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1RoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1RoleBindingList - -const _property_types_IoK8sApiRbacV1RoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1RoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1RoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1RoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1RoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1RoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleList.jl deleted file mode 100644 index 992513c4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.RoleList -RoleList is a collection of Roles - - IoK8sApiRbacV1RoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1Role} : Items is a list of Roles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1RoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1Role} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1RoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1RoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1RoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1RoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1RoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1RoleList - -const _property_types_IoK8sApiRbacV1RoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1Role}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1RoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1RoleList[name]))} - -function check_required(o::IoK8sApiRbacV1RoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1RoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleRef.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleRef.jl deleted file mode 100644 index f48b7e4e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1RoleRef.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.RoleRef -RoleRef contains information that points to the role being used - - IoK8sApiRbacV1RoleRef(; - apiGroup=nothing, - kind=nothing, - name=nothing, - ) - - - apiGroup::String : APIGroup is the group for the resource being referenced - - kind::String : Kind is the type of resource being referenced - - name::String : Name is the name of resource being referenced -""" -Base.@kwdef mutable struct IoK8sApiRbacV1RoleRef <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1RoleRef(apiGroup, kind, name, ) - OpenAPI.validate_property(IoK8sApiRbacV1RoleRef, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiRbacV1RoleRef, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1RoleRef, Symbol("name"), name) - return new(apiGroup, kind, name, ) - end -end # type IoK8sApiRbacV1RoleRef - -const _property_types_IoK8sApiRbacV1RoleRef = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1RoleRef }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1RoleRef[name]))} - -function check_required(o::IoK8sApiRbacV1RoleRef) - o.apiGroup === nothing && (return false) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1RoleRef }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1Subject.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1Subject.jl deleted file mode 100644 index 83419ad1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1Subject.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1.Subject -Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. - - IoK8sApiRbacV1Subject(; - apiGroup=nothing, - kind=nothing, - name=nothing, - namespace=nothing, - ) - - - apiGroup::String : APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects. - - kind::String : Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error. - - name::String : Name of the object being referenced. - - namespace::String : Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1Subject <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1Subject(apiGroup, kind, name, namespace, ) - OpenAPI.validate_property(IoK8sApiRbacV1Subject, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiRbacV1Subject, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1Subject, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiRbacV1Subject, Symbol("namespace"), namespace) - return new(apiGroup, kind, name, namespace, ) - end -end # type IoK8sApiRbacV1Subject - -const _property_types_IoK8sApiRbacV1Subject = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1Subject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1Subject[name]))} - -function check_required(o::IoK8sApiRbacV1Subject) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1Subject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1AggregationRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1AggregationRule.jl deleted file mode 100644 index 7c46e025..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1AggregationRule.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.AggregationRule -AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole - - IoK8sApiRbacV1alpha1AggregationRule(; - clusterRoleSelectors=nothing, - ) - - - clusterRoleSelectors::Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} : ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1AggregationRule <: OpenAPI.APIModel - clusterRoleSelectors::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} } - - function IoK8sApiRbacV1alpha1AggregationRule(clusterRoleSelectors, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1AggregationRule, Symbol("clusterRoleSelectors"), clusterRoleSelectors) - return new(clusterRoleSelectors, ) - end -end # type IoK8sApiRbacV1alpha1AggregationRule - -const _property_types_IoK8sApiRbacV1alpha1AggregationRule = Dict{Symbol,String}(Symbol("clusterRoleSelectors")=>"Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1AggregationRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1AggregationRule[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1AggregationRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1AggregationRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRole.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRole.jl deleted file mode 100644 index 47862a8d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRole.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.ClusterRole -ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1ClusterRole(; - aggregationRule=nothing, - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - aggregationRule::IoK8sApiRbacV1alpha1AggregationRule - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1alpha1PolicyRule} : Rules holds all the PolicyRules for this ClusterRole -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1ClusterRole <: OpenAPI.APIModel - aggregationRule = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1alpha1AggregationRule } - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1PolicyRule} } - - function IoK8sApiRbacV1alpha1ClusterRole(aggregationRule, apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRole, Symbol("aggregationRule"), aggregationRule) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRole, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRole, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRole, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRole, Symbol("rules"), rules) - return new(aggregationRule, apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1alpha1ClusterRole - -const _property_types_IoK8sApiRbacV1alpha1ClusterRole = Dict{Symbol,String}(Symbol("aggregationRule")=>"IoK8sApiRbacV1alpha1AggregationRule", Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1alpha1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1ClusterRole }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1ClusterRole[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1ClusterRole) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1ClusterRole }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBinding.jl deleted file mode 100644 index 9f839c84..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.ClusterRoleBinding -ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1ClusterRoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1alpha1RoleRef - - subjects::Vector{IoK8sApiRbacV1alpha1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1ClusterRoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1alpha1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1Subject} } - - function IoK8sApiRbacV1alpha1ClusterRoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1alpha1ClusterRoleBinding - -const _property_types_IoK8sApiRbacV1alpha1ClusterRoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1alpha1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1alpha1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1ClusterRoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1ClusterRoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1ClusterRoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1ClusterRoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBindingList.jl deleted file mode 100644 index c7ba134e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.ClusterRoleBindingList -ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindings, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1ClusterRoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1alpha1ClusterRoleBinding} : Items is a list of ClusterRoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1ClusterRoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1ClusterRoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1alpha1ClusterRoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1alpha1ClusterRoleBindingList - -const _property_types_IoK8sApiRbacV1alpha1ClusterRoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1alpha1ClusterRoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1ClusterRoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1ClusterRoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1ClusterRoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1ClusterRoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleList.jl deleted file mode 100644 index 17596ea1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1ClusterRoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.ClusterRoleList -ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1ClusterRoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1alpha1ClusterRole} : Items is a list of ClusterRoles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1ClusterRoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1ClusterRole} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1alpha1ClusterRoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1ClusterRoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1alpha1ClusterRoleList - -const _property_types_IoK8sApiRbacV1alpha1ClusterRoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1alpha1ClusterRole}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1ClusterRoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1ClusterRoleList[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1ClusterRoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1ClusterRoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1PolicyRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1PolicyRule.jl deleted file mode 100644 index 4862b767..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1PolicyRule.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.PolicyRule -PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. - - IoK8sApiRbacV1alpha1PolicyRule(; - apiGroups=nothing, - nonResourceURLs=nothing, - resourceNames=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. - - nonResourceURLs::Vector{String} : NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path This name is intentionally different than the internal type so that the DefaultConvert works nicely and because the ordering may be different. Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both. - - resourceNames::Vector{String} : ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. - - resources::Vector{String} : Resources is a list of resources this rule applies to. ResourceAll represents all resources. - - verbs::Vector{String} : Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1PolicyRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - resourceNames::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiRbacV1alpha1PolicyRule(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1PolicyRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1PolicyRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1PolicyRule, Symbol("resourceNames"), resourceNames) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1PolicyRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1PolicyRule, Symbol("verbs"), verbs) - return new(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - end -end # type IoK8sApiRbacV1alpha1PolicyRule - -const _property_types_IoK8sApiRbacV1alpha1PolicyRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("nonResourceURLs")=>"Vector{String}", Symbol("resourceNames")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1PolicyRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1PolicyRule[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1PolicyRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1PolicyRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Role.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Role.jl deleted file mode 100644 index 13a92c36..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Role.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.Role -Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1Role(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1alpha1PolicyRule} : Rules holds all the PolicyRules for this Role -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1Role <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1PolicyRule} } - - function IoK8sApiRbacV1alpha1Role(apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Role, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Role, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Role, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Role, Symbol("rules"), rules) - return new(apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1alpha1Role - -const _property_types_IoK8sApiRbacV1alpha1Role = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1alpha1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1Role }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1Role[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1Role) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1Role }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBinding.jl deleted file mode 100644 index 8880317e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.RoleBinding -RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1RoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1alpha1RoleRef - - subjects::Vector{IoK8sApiRbacV1alpha1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1RoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1alpha1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1Subject} } - - function IoK8sApiRbacV1alpha1RoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1alpha1RoleBinding - -const _property_types_IoK8sApiRbacV1alpha1RoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1alpha1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1alpha1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1RoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1RoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1RoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1RoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBindingList.jl deleted file mode 100644 index 801ec818..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.RoleBindingList -RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1RoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1alpha1RoleBinding} : Items is a list of RoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1RoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1RoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1alpha1RoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1alpha1RoleBindingList - -const _property_types_IoK8sApiRbacV1alpha1RoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1alpha1RoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1RoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1RoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1RoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1RoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleList.jl deleted file mode 100644 index d5785bfe..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.RoleList -RoleList is a collection of Roles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. - - IoK8sApiRbacV1alpha1RoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1alpha1Role} : Items is a list of Roles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1RoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1alpha1Role} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1alpha1RoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1alpha1RoleList - -const _property_types_IoK8sApiRbacV1alpha1RoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1alpha1Role}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1RoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1RoleList[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1RoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1RoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleRef.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleRef.jl deleted file mode 100644 index 9d89770d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1RoleRef.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.RoleRef -RoleRef contains information that points to the role being used - - IoK8sApiRbacV1alpha1RoleRef(; - apiGroup=nothing, - kind=nothing, - name=nothing, - ) - - - apiGroup::String : APIGroup is the group for the resource being referenced - - kind::String : Kind is the type of resource being referenced - - name::String : Name is the name of resource being referenced -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1RoleRef <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1alpha1RoleRef(apiGroup, kind, name, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleRef, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleRef, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1RoleRef, Symbol("name"), name) - return new(apiGroup, kind, name, ) - end -end # type IoK8sApiRbacV1alpha1RoleRef - -const _property_types_IoK8sApiRbacV1alpha1RoleRef = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1RoleRef }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1RoleRef[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1RoleRef) - o.apiGroup === nothing && (return false) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1RoleRef }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Subject.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Subject.jl deleted file mode 100644 index f7285c22..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1alpha1Subject.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1alpha1.Subject -Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. - - IoK8sApiRbacV1alpha1Subject(; - apiVersion=nothing, - kind=nothing, - name=nothing, - namespace=nothing, - ) - - - apiVersion::String : APIVersion holds the API group and version of the referenced subject. Defaults to \"v1\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io/v1alpha1\" for User and Group subjects. - - kind::String : Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error. - - name::String : Name of the object being referenced. - - namespace::String : Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1alpha1Subject <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1alpha1Subject(apiVersion, kind, name, namespace, ) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Subject, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Subject, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Subject, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiRbacV1alpha1Subject, Symbol("namespace"), namespace) - return new(apiVersion, kind, name, namespace, ) - end -end # type IoK8sApiRbacV1alpha1Subject - -const _property_types_IoK8sApiRbacV1alpha1Subject = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1alpha1Subject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1alpha1Subject[name]))} - -function check_required(o::IoK8sApiRbacV1alpha1Subject) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1alpha1Subject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1AggregationRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1AggregationRule.jl deleted file mode 100644 index f1240e6c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1AggregationRule.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.AggregationRule -AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole - - IoK8sApiRbacV1beta1AggregationRule(; - clusterRoleSelectors=nothing, - ) - - - clusterRoleSelectors::Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} : ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1AggregationRule <: OpenAPI.APIModel - clusterRoleSelectors::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector} } - - function IoK8sApiRbacV1beta1AggregationRule(clusterRoleSelectors, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1AggregationRule, Symbol("clusterRoleSelectors"), clusterRoleSelectors) - return new(clusterRoleSelectors, ) - end -end # type IoK8sApiRbacV1beta1AggregationRule - -const _property_types_IoK8sApiRbacV1beta1AggregationRule = Dict{Symbol,String}(Symbol("clusterRoleSelectors")=>"Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1AggregationRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1AggregationRule[name]))} - -function check_required(o::IoK8sApiRbacV1beta1AggregationRule) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1AggregationRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRole.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRole.jl deleted file mode 100644 index 282a371a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRole.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.ClusterRole -ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRole, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1ClusterRole(; - aggregationRule=nothing, - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - aggregationRule::IoK8sApiRbacV1beta1AggregationRule - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1beta1PolicyRule} : Rules holds all the PolicyRules for this ClusterRole -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1ClusterRole <: OpenAPI.APIModel - aggregationRule = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1beta1AggregationRule } - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1PolicyRule} } - - function IoK8sApiRbacV1beta1ClusterRole(aggregationRule, apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRole, Symbol("aggregationRule"), aggregationRule) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRole, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRole, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRole, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRole, Symbol("rules"), rules) - return new(aggregationRule, apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1beta1ClusterRole - -const _property_types_IoK8sApiRbacV1beta1ClusterRole = Dict{Symbol,String}(Symbol("aggregationRule")=>"IoK8sApiRbacV1beta1AggregationRule", Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1beta1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1ClusterRole }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1ClusterRole[name]))} - -function check_required(o::IoK8sApiRbacV1beta1ClusterRole) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1ClusterRole }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBinding.jl deleted file mode 100644 index f6c53d74..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.ClusterRoleBinding -ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBinding, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1ClusterRoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1beta1RoleRef - - subjects::Vector{IoK8sApiRbacV1beta1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1ClusterRoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1beta1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1Subject} } - - function IoK8sApiRbacV1beta1ClusterRoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1beta1ClusterRoleBinding - -const _property_types_IoK8sApiRbacV1beta1ClusterRoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1beta1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1beta1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1ClusterRoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1ClusterRoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1beta1ClusterRoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1ClusterRoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBindingList.jl deleted file mode 100644 index 82bc034e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.ClusterRoleBindingList -ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindingList, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1ClusterRoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1beta1ClusterRoleBinding} : Items is a list of ClusterRoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1ClusterRoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1ClusterRoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1beta1ClusterRoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1beta1ClusterRoleBindingList - -const _property_types_IoK8sApiRbacV1beta1ClusterRoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1beta1ClusterRoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1ClusterRoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1ClusterRoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1beta1ClusterRoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1ClusterRoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleList.jl deleted file mode 100644 index 2e52d3c1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1ClusterRoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.ClusterRoleList -ClusterRoleList is a collection of ClusterRoles. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoles, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1ClusterRoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1beta1ClusterRole} : Items is a list of ClusterRoles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1ClusterRoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1ClusterRole} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1beta1ClusterRoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1ClusterRoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1beta1ClusterRoleList - -const _property_types_IoK8sApiRbacV1beta1ClusterRoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1beta1ClusterRole}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1ClusterRoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1ClusterRoleList[name]))} - -function check_required(o::IoK8sApiRbacV1beta1ClusterRoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1ClusterRoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1PolicyRule.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1PolicyRule.jl deleted file mode 100644 index e393f6f0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1PolicyRule.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.PolicyRule -PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. - - IoK8sApiRbacV1beta1PolicyRule(; - apiGroups=nothing, - nonResourceURLs=nothing, - resourceNames=nothing, - resources=nothing, - verbs=nothing, - ) - - - apiGroups::Vector{String} : APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. - - nonResourceURLs::Vector{String} : NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both. - - resourceNames::Vector{String} : ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. - - resources::Vector{String} : Resources is a list of resources this rule applies to. '*' represents all resources in the specified apiGroups. '*/foo' represents the subresource 'foo' for all resources in the specified apiGroups. - - verbs::Vector{String} : Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1PolicyRule <: OpenAPI.APIModel - apiGroups::Union{Nothing, Vector{String}} = nothing - nonResourceURLs::Union{Nothing, Vector{String}} = nothing - resourceNames::Union{Nothing, Vector{String}} = nothing - resources::Union{Nothing, Vector{String}} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiRbacV1beta1PolicyRule(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1PolicyRule, Symbol("apiGroups"), apiGroups) - OpenAPI.validate_property(IoK8sApiRbacV1beta1PolicyRule, Symbol("nonResourceURLs"), nonResourceURLs) - OpenAPI.validate_property(IoK8sApiRbacV1beta1PolicyRule, Symbol("resourceNames"), resourceNames) - OpenAPI.validate_property(IoK8sApiRbacV1beta1PolicyRule, Symbol("resources"), resources) - OpenAPI.validate_property(IoK8sApiRbacV1beta1PolicyRule, Symbol("verbs"), verbs) - return new(apiGroups, nonResourceURLs, resourceNames, resources, verbs, ) - end -end # type IoK8sApiRbacV1beta1PolicyRule - -const _property_types_IoK8sApiRbacV1beta1PolicyRule = Dict{Symbol,String}(Symbol("apiGroups")=>"Vector{String}", Symbol("nonResourceURLs")=>"Vector{String}", Symbol("resourceNames")=>"Vector{String}", Symbol("resources")=>"Vector{String}", Symbol("verbs")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1PolicyRule }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1PolicyRule[name]))} - -function check_required(o::IoK8sApiRbacV1beta1PolicyRule) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1PolicyRule }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Role.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Role.jl deleted file mode 100644 index 714bc83b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Role.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.Role -Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 Role, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1Role(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - rules=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - rules::Vector{IoK8sApiRbacV1beta1PolicyRule} : Rules holds all the PolicyRules for this Role -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1Role <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - rules::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1PolicyRule} } - - function IoK8sApiRbacV1beta1Role(apiVersion, kind, metadata, rules, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Role, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Role, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Role, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Role, Symbol("rules"), rules) - return new(apiVersion, kind, metadata, rules, ) - end -end # type IoK8sApiRbacV1beta1Role - -const _property_types_IoK8sApiRbacV1beta1Role = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("rules")=>"Vector{IoK8sApiRbacV1beta1PolicyRule}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1Role }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1Role[name]))} - -function check_required(o::IoK8sApiRbacV1beta1Role) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1Role }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBinding.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBinding.jl deleted file mode 100644 index 749abf0d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBinding.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.RoleBinding -RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBinding, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1RoleBinding(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - roleRef=nothing, - subjects=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - roleRef::IoK8sApiRbacV1beta1RoleRef - - subjects::Vector{IoK8sApiRbacV1beta1Subject} : Subjects holds references to the objects the role applies to. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1RoleBinding <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - roleRef = nothing # spec type: Union{ Nothing, IoK8sApiRbacV1beta1RoleRef } - subjects::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1Subject} } - - function IoK8sApiRbacV1beta1RoleBinding(apiVersion, kind, metadata, roleRef, subjects, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBinding, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBinding, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBinding, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBinding, Symbol("roleRef"), roleRef) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBinding, Symbol("subjects"), subjects) - return new(apiVersion, kind, metadata, roleRef, subjects, ) - end -end # type IoK8sApiRbacV1beta1RoleBinding - -const _property_types_IoK8sApiRbacV1beta1RoleBinding = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("roleRef")=>"IoK8sApiRbacV1beta1RoleRef", Symbol("subjects")=>"Vector{IoK8sApiRbacV1beta1Subject}", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1RoleBinding }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1RoleBinding[name]))} - -function check_required(o::IoK8sApiRbacV1beta1RoleBinding) - o.roleRef === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1RoleBinding }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBindingList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBindingList.jl deleted file mode 100644 index a300697c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleBindingList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.RoleBindingList -RoleBindingList is a collection of RoleBindings Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleBindingList, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1RoleBindingList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1beta1RoleBinding} : Items is a list of RoleBindings - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1RoleBindingList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1RoleBinding} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1beta1RoleBindingList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBindingList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBindingList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBindingList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleBindingList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1beta1RoleBindingList - -const _property_types_IoK8sApiRbacV1beta1RoleBindingList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1beta1RoleBinding}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1RoleBindingList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1RoleBindingList[name]))} - -function check_required(o::IoK8sApiRbacV1beta1RoleBindingList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1RoleBindingList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleList.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleList.jl deleted file mode 100644 index c8f1d68f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.RoleList -RoleList is a collection of Roles Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 RoleList, and will no longer be served in v1.20. - - IoK8sApiRbacV1beta1RoleList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiRbacV1beta1Role} : Items is a list of Roles - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1RoleList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiRbacV1beta1Role} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiRbacV1beta1RoleList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiRbacV1beta1RoleList - -const _property_types_IoK8sApiRbacV1beta1RoleList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiRbacV1beta1Role}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1RoleList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1RoleList[name]))} - -function check_required(o::IoK8sApiRbacV1beta1RoleList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1RoleList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleRef.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleRef.jl deleted file mode 100644 index fc269f22..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1RoleRef.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.RoleRef -RoleRef contains information that points to the role being used - - IoK8sApiRbacV1beta1RoleRef(; - apiGroup=nothing, - kind=nothing, - name=nothing, - ) - - - apiGroup::String : APIGroup is the group for the resource being referenced - - kind::String : Kind is the type of resource being referenced - - name::String : Name is the name of resource being referenced -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1RoleRef <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1beta1RoleRef(apiGroup, kind, name, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleRef, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleRef, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1RoleRef, Symbol("name"), name) - return new(apiGroup, kind, name, ) - end -end # type IoK8sApiRbacV1beta1RoleRef - -const _property_types_IoK8sApiRbacV1beta1RoleRef = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1RoleRef }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1RoleRef[name]))} - -function check_required(o::IoK8sApiRbacV1beta1RoleRef) - o.apiGroup === nothing && (return false) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1RoleRef }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Subject.jl b/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Subject.jl deleted file mode 100644 index 00286686..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiRbacV1beta1Subject.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.rbac.v1beta1.Subject -Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. - - IoK8sApiRbacV1beta1Subject(; - apiGroup=nothing, - kind=nothing, - name=nothing, - namespace=nothing, - ) - - - apiGroup::String : APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects. - - kind::String : Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error. - - name::String : Name of the object being referenced. - - namespace::String : Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error. -""" -Base.@kwdef mutable struct IoK8sApiRbacV1beta1Subject <: OpenAPI.APIModel - apiGroup::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - - function IoK8sApiRbacV1beta1Subject(apiGroup, kind, name, namespace, ) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Subject, Symbol("apiGroup"), apiGroup) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Subject, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Subject, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiRbacV1beta1Subject, Symbol("namespace"), namespace) - return new(apiGroup, kind, name, namespace, ) - end -end # type IoK8sApiRbacV1beta1Subject - -const _property_types_IoK8sApiRbacV1beta1Subject = Dict{Symbol,String}(Symbol("apiGroup")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("namespace")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiRbacV1beta1Subject }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiRbacV1beta1Subject[name]))} - -function check_required(o::IoK8sApiRbacV1beta1Subject) - o.kind === nothing && (return false) - o.name === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiRbacV1beta1Subject }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClass.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClass.jl deleted file mode 100644 index 6cd607ac..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClass.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1.PriorityClass -PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. - - IoK8sApiSchedulingV1PriorityClass(; - apiVersion=nothing, - description=nothing, - globalDefault=nothing, - kind=nothing, - metadata=nothing, - preemptionPolicy=nothing, - value=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - description::String : description is an arbitrary string that usually provides guidelines on when this priority class should be used. - - globalDefault::Bool : globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - preemptionPolicy::String : PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. - - value::Int64 : The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec. -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1PriorityClass <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - description::Union{Nothing, String} = nothing - globalDefault::Union{Nothing, Bool} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - preemptionPolicy::Union{Nothing, String} = nothing - value::Union{Nothing, Int64} = nothing - - function IoK8sApiSchedulingV1PriorityClass(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("globalDefault"), globalDefault) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("preemptionPolicy"), preemptionPolicy) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClass, Symbol("value"), value) - return new(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - end -end # type IoK8sApiSchedulingV1PriorityClass - -const _property_types_IoK8sApiSchedulingV1PriorityClass = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("description")=>"String", Symbol("globalDefault")=>"Bool", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("preemptionPolicy")=>"String", Symbol("value")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1PriorityClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1PriorityClass[name]))} - -function check_required(o::IoK8sApiSchedulingV1PriorityClass) - o.value === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1PriorityClass }, name::Symbol, val) - if name === Symbol("value") - OpenAPI.validate_param(name, "IoK8sApiSchedulingV1PriorityClass", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClassList.jl deleted file mode 100644 index 25fb14e5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1PriorityClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1.PriorityClassList -PriorityClassList is a collection of priority classes. - - IoK8sApiSchedulingV1PriorityClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiSchedulingV1PriorityClass} : items is the list of PriorityClasses - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1PriorityClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiSchedulingV1PriorityClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiSchedulingV1PriorityClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1PriorityClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiSchedulingV1PriorityClassList - -const _property_types_IoK8sApiSchedulingV1PriorityClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiSchedulingV1PriorityClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1PriorityClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1PriorityClassList[name]))} - -function check_required(o::IoK8sApiSchedulingV1PriorityClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1PriorityClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClass.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClass.jl deleted file mode 100644 index 743a8210..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClass.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1alpha1.PriorityClass -DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. - - IoK8sApiSchedulingV1alpha1PriorityClass(; - apiVersion=nothing, - description=nothing, - globalDefault=nothing, - kind=nothing, - metadata=nothing, - preemptionPolicy=nothing, - value=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - description::String : description is an arbitrary string that usually provides guidelines on when this priority class should be used. - - globalDefault::Bool : globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - preemptionPolicy::String : PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. - - value::Int64 : The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec. -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1alpha1PriorityClass <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - description::Union{Nothing, String} = nothing - globalDefault::Union{Nothing, Bool} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - preemptionPolicy::Union{Nothing, String} = nothing - value::Union{Nothing, Int64} = nothing - - function IoK8sApiSchedulingV1alpha1PriorityClass(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("globalDefault"), globalDefault) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("preemptionPolicy"), preemptionPolicy) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClass, Symbol("value"), value) - return new(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - end -end # type IoK8sApiSchedulingV1alpha1PriorityClass - -const _property_types_IoK8sApiSchedulingV1alpha1PriorityClass = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("description")=>"String", Symbol("globalDefault")=>"Bool", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("preemptionPolicy")=>"String", Symbol("value")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1alpha1PriorityClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1alpha1PriorityClass[name]))} - -function check_required(o::IoK8sApiSchedulingV1alpha1PriorityClass) - o.value === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1alpha1PriorityClass }, name::Symbol, val) - if name === Symbol("value") - OpenAPI.validate_param(name, "IoK8sApiSchedulingV1alpha1PriorityClass", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClassList.jl deleted file mode 100644 index f2e81acc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1alpha1PriorityClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1alpha1.PriorityClassList -PriorityClassList is a collection of priority classes. - - IoK8sApiSchedulingV1alpha1PriorityClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiSchedulingV1alpha1PriorityClass} : items is the list of PriorityClasses - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1alpha1PriorityClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiSchedulingV1alpha1PriorityClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiSchedulingV1alpha1PriorityClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1alpha1PriorityClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiSchedulingV1alpha1PriorityClassList - -const _property_types_IoK8sApiSchedulingV1alpha1PriorityClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiSchedulingV1alpha1PriorityClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1alpha1PriorityClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1alpha1PriorityClassList[name]))} - -function check_required(o::IoK8sApiSchedulingV1alpha1PriorityClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1alpha1PriorityClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClass.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClass.jl deleted file mode 100644 index 2bdcad8d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClass.jl +++ /dev/null @@ -1,59 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1beta1.PriorityClass -DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. - - IoK8sApiSchedulingV1beta1PriorityClass(; - apiVersion=nothing, - description=nothing, - globalDefault=nothing, - kind=nothing, - metadata=nothing, - preemptionPolicy=nothing, - value=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - description::String : description is an arbitrary string that usually provides guidelines on when this priority class should be used. - - globalDefault::Bool : globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - preemptionPolicy::String : PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. - - value::Int64 : The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec. -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1beta1PriorityClass <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - description::Union{Nothing, String} = nothing - globalDefault::Union{Nothing, Bool} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - preemptionPolicy::Union{Nothing, String} = nothing - value::Union{Nothing, Int64} = nothing - - function IoK8sApiSchedulingV1beta1PriorityClass(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("globalDefault"), globalDefault) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("preemptionPolicy"), preemptionPolicy) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClass, Symbol("value"), value) - return new(apiVersion, description, globalDefault, kind, metadata, preemptionPolicy, value, ) - end -end # type IoK8sApiSchedulingV1beta1PriorityClass - -const _property_types_IoK8sApiSchedulingV1beta1PriorityClass = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("description")=>"String", Symbol("globalDefault")=>"Bool", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("preemptionPolicy")=>"String", Symbol("value")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1beta1PriorityClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1beta1PriorityClass[name]))} - -function check_required(o::IoK8sApiSchedulingV1beta1PriorityClass) - o.value === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1beta1PriorityClass }, name::Symbol, val) - if name === Symbol("value") - OpenAPI.validate_param(name, "IoK8sApiSchedulingV1beta1PriorityClass", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClassList.jl deleted file mode 100644 index 4ce82a69..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSchedulingV1beta1PriorityClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.scheduling.v1beta1.PriorityClassList -PriorityClassList is a collection of priority classes. - - IoK8sApiSchedulingV1beta1PriorityClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiSchedulingV1beta1PriorityClass} : items is the list of PriorityClasses - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiSchedulingV1beta1PriorityClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiSchedulingV1beta1PriorityClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiSchedulingV1beta1PriorityClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSchedulingV1beta1PriorityClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiSchedulingV1beta1PriorityClassList - -const _property_types_IoK8sApiSchedulingV1beta1PriorityClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiSchedulingV1beta1PriorityClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiSchedulingV1beta1PriorityClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSchedulingV1beta1PriorityClassList[name]))} - -function check_required(o::IoK8sApiSchedulingV1beta1PriorityClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSchedulingV1beta1PriorityClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPreset.jl b/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPreset.jl deleted file mode 100644 index a09ccc75..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPreset.jl +++ /dev/null @@ -1,43 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.settings.v1alpha1.PodPreset -PodPreset is a policy resource that defines additional runtime requirements for a Pod. - - IoK8sApiSettingsV1alpha1PodPreset(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiSettingsV1alpha1PodPresetSpec -""" -Base.@kwdef mutable struct IoK8sApiSettingsV1alpha1PodPreset <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiSettingsV1alpha1PodPresetSpec } - - function IoK8sApiSettingsV1alpha1PodPreset(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPreset, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPreset, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPreset, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPreset, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiSettingsV1alpha1PodPreset - -const _property_types_IoK8sApiSettingsV1alpha1PodPreset = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiSettingsV1alpha1PodPresetSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiSettingsV1alpha1PodPreset }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSettingsV1alpha1PodPreset[name]))} - -function check_required(o::IoK8sApiSettingsV1alpha1PodPreset) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSettingsV1alpha1PodPreset }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetList.jl b/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetList.jl deleted file mode 100644 index bb757158..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.settings.v1alpha1.PodPresetList -PodPresetList is a list of PodPreset objects. - - IoK8sApiSettingsV1alpha1PodPresetList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiSettingsV1alpha1PodPreset} : Items is a list of schema objects. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiSettingsV1alpha1PodPresetList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiSettingsV1alpha1PodPreset} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiSettingsV1alpha1PodPresetList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiSettingsV1alpha1PodPresetList - -const _property_types_IoK8sApiSettingsV1alpha1PodPresetList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiSettingsV1alpha1PodPreset}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiSettingsV1alpha1PodPresetList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSettingsV1alpha1PodPresetList[name]))} - -function check_required(o::IoK8sApiSettingsV1alpha1PodPresetList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSettingsV1alpha1PodPresetList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetSpec.jl deleted file mode 100644 index 8279ae35..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiSettingsV1alpha1PodPresetSpec.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.settings.v1alpha1.PodPresetSpec -PodPresetSpec is a description of a pod preset. - - IoK8sApiSettingsV1alpha1PodPresetSpec(; - env=nothing, - envFrom=nothing, - selector=nothing, - volumeMounts=nothing, - volumes=nothing, - ) - - - env::Vector{IoK8sApiCoreV1EnvVar} : Env defines the collection of EnvVar to inject into containers. - - envFrom::Vector{IoK8sApiCoreV1EnvFromSource} : EnvFrom defines the collection of EnvFromSource to inject into containers. - - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector - - volumeMounts::Vector{IoK8sApiCoreV1VolumeMount} : VolumeMounts defines the collection of VolumeMount to inject into containers. - - volumes::Vector{IoK8sApiCoreV1Volume} : Volumes defines the collection of Volume to inject into the pod. -""" -Base.@kwdef mutable struct IoK8sApiSettingsV1alpha1PodPresetSpec <: OpenAPI.APIModel - env::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvVar} } - envFrom::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1EnvFromSource} } - selector = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } - volumeMounts::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1VolumeMount} } - volumes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1Volume} } - - function IoK8sApiSettingsV1alpha1PodPresetSpec(env, envFrom, selector, volumeMounts, volumes, ) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetSpec, Symbol("env"), env) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetSpec, Symbol("envFrom"), envFrom) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetSpec, Symbol("selector"), selector) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetSpec, Symbol("volumeMounts"), volumeMounts) - OpenAPI.validate_property(IoK8sApiSettingsV1alpha1PodPresetSpec, Symbol("volumes"), volumes) - return new(env, envFrom, selector, volumeMounts, volumes, ) - end -end # type IoK8sApiSettingsV1alpha1PodPresetSpec - -const _property_types_IoK8sApiSettingsV1alpha1PodPresetSpec = Dict{Symbol,String}(Symbol("env")=>"Vector{IoK8sApiCoreV1EnvVar}", Symbol("envFrom")=>"Vector{IoK8sApiCoreV1EnvFromSource}", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("volumeMounts")=>"Vector{IoK8sApiCoreV1VolumeMount}", Symbol("volumes")=>"Vector{IoK8sApiCoreV1Volume}", ) -OpenAPI.property_type(::Type{ IoK8sApiSettingsV1alpha1PodPresetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiSettingsV1alpha1PodPresetSpec[name]))} - -function check_required(o::IoK8sApiSettingsV1alpha1PodPresetSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiSettingsV1alpha1PodPresetSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINode.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINode.jl deleted file mode 100644 index ea34826a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINode.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.CSINode -CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. - - IoK8sApiStorageV1CSINode(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1CSINodeSpec -""" -Base.@kwdef mutable struct IoK8sApiStorageV1CSINode <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1CSINodeSpec } - - function IoK8sApiStorageV1CSINode(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiStorageV1CSINode, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1CSINode, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1CSINode, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1CSINode, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiStorageV1CSINode - -const _property_types_IoK8sApiStorageV1CSINode = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1CSINodeSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1CSINode }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1CSINode[name]))} - -function check_required(o::IoK8sApiStorageV1CSINode) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1CSINode }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeDriver.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeDriver.jl deleted file mode 100644 index c8dbd3ba..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeDriver.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.CSINodeDriver -CSINodeDriver holds information about the specification of one CSI driver installed on a node - - IoK8sApiStorageV1CSINodeDriver(; - allocatable=nothing, - name=nothing, - nodeID=nothing, - topologyKeys=nothing, - ) - - - allocatable::IoK8sApiStorageV1VolumeNodeResources - - name::String : This is the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver. - - nodeID::String : nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as \"node1\", but the storage system may refer to the same node as \"nodeA\". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. \"nodeA\" instead of \"node1\". This field is required. - - topologyKeys::Vector{String} : topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. \"company.com/zone\", \"company.com/region\"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1CSINodeDriver <: OpenAPI.APIModel - allocatable = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeNodeResources } - name::Union{Nothing, String} = nothing - nodeID::Union{Nothing, String} = nothing - topologyKeys::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiStorageV1CSINodeDriver(allocatable, name, nodeID, topologyKeys, ) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeDriver, Symbol("allocatable"), allocatable) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeDriver, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeDriver, Symbol("nodeID"), nodeID) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeDriver, Symbol("topologyKeys"), topologyKeys) - return new(allocatable, name, nodeID, topologyKeys, ) - end -end # type IoK8sApiStorageV1CSINodeDriver - -const _property_types_IoK8sApiStorageV1CSINodeDriver = Dict{Symbol,String}(Symbol("allocatable")=>"IoK8sApiStorageV1VolumeNodeResources", Symbol("name")=>"String", Symbol("nodeID")=>"String", Symbol("topologyKeys")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1CSINodeDriver }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1CSINodeDriver[name]))} - -function check_required(o::IoK8sApiStorageV1CSINodeDriver) - o.name === nothing && (return false) - o.nodeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1CSINodeDriver }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeList.jl deleted file mode 100644 index b8068827..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.CSINodeList -CSINodeList is a collection of CSINode objects. - - IoK8sApiStorageV1CSINodeList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1CSINode} : items is the list of CSINode - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1CSINodeList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1CSINode} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1CSINodeList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1CSINodeList - -const _property_types_IoK8sApiStorageV1CSINodeList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1CSINode}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1CSINodeList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1CSINodeList[name]))} - -function check_required(o::IoK8sApiStorageV1CSINodeList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1CSINodeList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeSpec.jl deleted file mode 100644 index 4e8f3e7d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1CSINodeSpec.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.CSINodeSpec -CSINodeSpec holds information about the specification of all CSI drivers installed on a node - - IoK8sApiStorageV1CSINodeSpec(; - drivers=nothing, - ) - - - drivers::Vector{IoK8sApiStorageV1CSINodeDriver} : drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1CSINodeSpec <: OpenAPI.APIModel - drivers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1CSINodeDriver} } - - function IoK8sApiStorageV1CSINodeSpec(drivers, ) - OpenAPI.validate_property(IoK8sApiStorageV1CSINodeSpec, Symbol("drivers"), drivers) - return new(drivers, ) - end -end # type IoK8sApiStorageV1CSINodeSpec - -const _property_types_IoK8sApiStorageV1CSINodeSpec = Dict{Symbol,String}(Symbol("drivers")=>"Vector{IoK8sApiStorageV1CSINodeDriver}", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1CSINodeSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1CSINodeSpec[name]))} - -function check_required(o::IoK8sApiStorageV1CSINodeSpec) - o.drivers === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1CSINodeSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClass.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClass.jl deleted file mode 100644 index 2942ac14..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClass.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.StorageClass -StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. - - IoK8sApiStorageV1StorageClass(; - allowVolumeExpansion=nothing, - allowedTopologies=nothing, - apiVersion=nothing, - kind=nothing, - metadata=nothing, - mountOptions=nothing, - parameters=nothing, - provisioner=nothing, - reclaimPolicy=nothing, - volumeBindingMode=nothing, - ) - - - allowVolumeExpansion::Bool : AllowVolumeExpansion shows whether the storage class allow volume expand - - allowedTopologies::Vector{IoK8sApiCoreV1TopologySelectorTerm} : Restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature. - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - mountOptions::Vector{String} : Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid. - - parameters::Dict{String, String} : Parameters holds the parameters for the provisioner that should create volumes of this storage class. - - provisioner::String : Provisioner indicates the type of the provisioner. - - reclaimPolicy::String : Dynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete. - - volumeBindingMode::String : VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1StorageClass <: OpenAPI.APIModel - allowVolumeExpansion::Union{Nothing, Bool} = nothing - allowedTopologies::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1TopologySelectorTerm} } - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - mountOptions::Union{Nothing, Vector{String}} = nothing - parameters::Union{Nothing, Dict{String, String}} = nothing - provisioner::Union{Nothing, String} = nothing - reclaimPolicy::Union{Nothing, String} = nothing - volumeBindingMode::Union{Nothing, String} = nothing - - function IoK8sApiStorageV1StorageClass(allowVolumeExpansion, allowedTopologies, apiVersion, kind, metadata, mountOptions, parameters, provisioner, reclaimPolicy, volumeBindingMode, ) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("allowVolumeExpansion"), allowVolumeExpansion) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("allowedTopologies"), allowedTopologies) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("mountOptions"), mountOptions) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("parameters"), parameters) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("provisioner"), provisioner) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("reclaimPolicy"), reclaimPolicy) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClass, Symbol("volumeBindingMode"), volumeBindingMode) - return new(allowVolumeExpansion, allowedTopologies, apiVersion, kind, metadata, mountOptions, parameters, provisioner, reclaimPolicy, volumeBindingMode, ) - end -end # type IoK8sApiStorageV1StorageClass - -const _property_types_IoK8sApiStorageV1StorageClass = Dict{Symbol,String}(Symbol("allowVolumeExpansion")=>"Bool", Symbol("allowedTopologies")=>"Vector{IoK8sApiCoreV1TopologySelectorTerm}", Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("mountOptions")=>"Vector{String}", Symbol("parameters")=>"Dict{String, String}", Symbol("provisioner")=>"String", Symbol("reclaimPolicy")=>"String", Symbol("volumeBindingMode")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1StorageClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1StorageClass[name]))} - -function check_required(o::IoK8sApiStorageV1StorageClass) - o.provisioner === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1StorageClass }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClassList.jl deleted file mode 100644 index e162d4cd..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1StorageClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.StorageClassList -StorageClassList is a collection of storage classes. - - IoK8sApiStorageV1StorageClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1StorageClass} : Items is the list of StorageClasses - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1StorageClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1StorageClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1StorageClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1StorageClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1StorageClassList - -const _property_types_IoK8sApiStorageV1StorageClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1StorageClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1StorageClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1StorageClassList[name]))} - -function check_required(o::IoK8sApiStorageV1StorageClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1StorageClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachment.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachment.jl deleted file mode 100644 index eadfe362..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachment.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeAttachment -VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced. - - IoK8sApiStorageV1VolumeAttachment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1VolumeAttachmentSpec - - status::IoK8sApiStorageV1VolumeAttachmentStatus -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeAttachment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeAttachmentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeAttachmentStatus } - - function IoK8sApiStorageV1VolumeAttachment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiStorageV1VolumeAttachment - -const _property_types_IoK8sApiStorageV1VolumeAttachment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1VolumeAttachmentSpec", Symbol("status")=>"IoK8sApiStorageV1VolumeAttachmentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeAttachment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeAttachment[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeAttachment) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeAttachment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentList.jl deleted file mode 100644 index f78f83d0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeAttachmentList -VolumeAttachmentList is a collection of VolumeAttachment objects. - - IoK8sApiStorageV1VolumeAttachmentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1VolumeAttachment} : Items is the list of VolumeAttachments - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeAttachmentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1VolumeAttachment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1VolumeAttachmentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1VolumeAttachmentList - -const _property_types_IoK8sApiStorageV1VolumeAttachmentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1VolumeAttachment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeAttachmentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeAttachmentList[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeAttachmentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeAttachmentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSource.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSource.jl deleted file mode 100644 index ae465e8c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeAttachmentSource -VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. - - IoK8sApiStorageV1VolumeAttachmentSource(; - inlineVolumeSpec=nothing, - persistentVolumeName=nothing, - ) - - - inlineVolumeSpec::IoK8sApiCoreV1PersistentVolumeSpec - - persistentVolumeName::String : Name of the persistent volume to attach. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeAttachmentSource <: OpenAPI.APIModel - inlineVolumeSpec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeSpec } - persistentVolumeName::Union{Nothing, String} = nothing - - function IoK8sApiStorageV1VolumeAttachmentSource(inlineVolumeSpec, persistentVolumeName, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentSource, Symbol("inlineVolumeSpec"), inlineVolumeSpec) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentSource, Symbol("persistentVolumeName"), persistentVolumeName) - return new(inlineVolumeSpec, persistentVolumeName, ) - end -end # type IoK8sApiStorageV1VolumeAttachmentSource - -const _property_types_IoK8sApiStorageV1VolumeAttachmentSource = Dict{Symbol,String}(Symbol("inlineVolumeSpec")=>"IoK8sApiCoreV1PersistentVolumeSpec", Symbol("persistentVolumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeAttachmentSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeAttachmentSource[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeAttachmentSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeAttachmentSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSpec.jl deleted file mode 100644 index 3ec93c7c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentSpec.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeAttachmentSpec -VolumeAttachmentSpec is the specification of a VolumeAttachment request. - - IoK8sApiStorageV1VolumeAttachmentSpec(; - attacher=nothing, - nodeName=nothing, - source=nothing, - ) - - - attacher::String : Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). - - nodeName::String : The node that the volume should be attached to. - - source::IoK8sApiStorageV1VolumeAttachmentSource -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeAttachmentSpec <: OpenAPI.APIModel - attacher::Union{Nothing, String} = nothing - nodeName::Union{Nothing, String} = nothing - source = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeAttachmentSource } - - function IoK8sApiStorageV1VolumeAttachmentSpec(attacher, nodeName, source, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentSpec, Symbol("attacher"), attacher) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentSpec, Symbol("nodeName"), nodeName) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentSpec, Symbol("source"), source) - return new(attacher, nodeName, source, ) - end -end # type IoK8sApiStorageV1VolumeAttachmentSpec - -const _property_types_IoK8sApiStorageV1VolumeAttachmentSpec = Dict{Symbol,String}(Symbol("attacher")=>"String", Symbol("nodeName")=>"String", Symbol("source")=>"IoK8sApiStorageV1VolumeAttachmentSource", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeAttachmentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeAttachmentSpec[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeAttachmentSpec) - o.attacher === nothing && (return false) - o.nodeName === nothing && (return false) - o.source === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeAttachmentSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentStatus.jl deleted file mode 100644 index 68405b86..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeAttachmentStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeAttachmentStatus -VolumeAttachmentStatus is the status of a VolumeAttachment request. - - IoK8sApiStorageV1VolumeAttachmentStatus(; - attachError=nothing, - attached=nothing, - attachmentMetadata=nothing, - detachError=nothing, - ) - - - attachError::IoK8sApiStorageV1VolumeError - - attached::Bool : Indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - attachmentMetadata::Dict{String, String} : Upon successful attach, this field is populated with any information returned by the attach operation that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - detachError::IoK8sApiStorageV1VolumeError -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeAttachmentStatus <: OpenAPI.APIModel - attachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeError } - attached::Union{Nothing, Bool} = nothing - attachmentMetadata::Union{Nothing, Dict{String, String}} = nothing - detachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1VolumeError } - - function IoK8sApiStorageV1VolumeAttachmentStatus(attachError, attached, attachmentMetadata, detachError, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentStatus, Symbol("attachError"), attachError) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentStatus, Symbol("attached"), attached) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentStatus, Symbol("attachmentMetadata"), attachmentMetadata) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeAttachmentStatus, Symbol("detachError"), detachError) - return new(attachError, attached, attachmentMetadata, detachError, ) - end -end # type IoK8sApiStorageV1VolumeAttachmentStatus - -const _property_types_IoK8sApiStorageV1VolumeAttachmentStatus = Dict{Symbol,String}(Symbol("attachError")=>"IoK8sApiStorageV1VolumeError", Symbol("attached")=>"Bool", Symbol("attachmentMetadata")=>"Dict{String, String}", Symbol("detachError")=>"IoK8sApiStorageV1VolumeError", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeAttachmentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeAttachmentStatus[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeAttachmentStatus) - o.attached === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeAttachmentStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeError.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeError.jl deleted file mode 100644 index c2937cdc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeError.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeError -VolumeError captures an error encountered during a volume operation. - - IoK8sApiStorageV1VolumeError(; - message=nothing, - time=nothing, - ) - - - message::String : String detailing the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. - - time::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeError <: OpenAPI.APIModel - message::Union{Nothing, String} = nothing - time::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiStorageV1VolumeError(message, time, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeError, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeError, Symbol("time"), time) - return new(message, time, ) - end -end # type IoK8sApiStorageV1VolumeError - -const _property_types_IoK8sApiStorageV1VolumeError = Dict{Symbol,String}(Symbol("message")=>"String", Symbol("time")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeError }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeError[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeError) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeError }, name::Symbol, val) - if name === Symbol("time") - OpenAPI.validate_param(name, "IoK8sApiStorageV1VolumeError", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeNodeResources.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeNodeResources.jl deleted file mode 100644 index 160d62aa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1VolumeNodeResources.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1.VolumeNodeResources -VolumeNodeResources is a set of resource limits for scheduling of volumes. - - IoK8sApiStorageV1VolumeNodeResources(; - count=nothing, - ) - - - count::Int64 : Maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1VolumeNodeResources <: OpenAPI.APIModel - count::Union{Nothing, Int64} = nothing - - function IoK8sApiStorageV1VolumeNodeResources(count, ) - OpenAPI.validate_property(IoK8sApiStorageV1VolumeNodeResources, Symbol("count"), count) - return new(count, ) - end -end # type IoK8sApiStorageV1VolumeNodeResources - -const _property_types_IoK8sApiStorageV1VolumeNodeResources = Dict{Symbol,String}(Symbol("count")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1VolumeNodeResources }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1VolumeNodeResources[name]))} - -function check_required(o::IoK8sApiStorageV1VolumeNodeResources) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1VolumeNodeResources }, name::Symbol, val) - if name === Symbol("count") - OpenAPI.validate_param(name, "IoK8sApiStorageV1VolumeNodeResources", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachment.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachment.jl deleted file mode 100644 index 498307e2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachment.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeAttachment -VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced. - - IoK8sApiStorageV1alpha1VolumeAttachment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1alpha1VolumeAttachmentSpec - - status::IoK8sApiStorageV1alpha1VolumeAttachmentStatus -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeAttachment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1alpha1VolumeAttachmentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1alpha1VolumeAttachmentStatus } - - function IoK8sApiStorageV1alpha1VolumeAttachment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiStorageV1alpha1VolumeAttachment - -const _property_types_IoK8sApiStorageV1alpha1VolumeAttachment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1alpha1VolumeAttachmentSpec", Symbol("status")=>"IoK8sApiStorageV1alpha1VolumeAttachmentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeAttachment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeAttachment[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeAttachment) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeAttachment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentList.jl deleted file mode 100644 index 0c99fd89..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeAttachmentList -VolumeAttachmentList is a collection of VolumeAttachment objects. - - IoK8sApiStorageV1alpha1VolumeAttachmentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1alpha1VolumeAttachment} : Items is the list of VolumeAttachments - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeAttachmentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1alpha1VolumeAttachment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1alpha1VolumeAttachmentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1alpha1VolumeAttachmentList - -const _property_types_IoK8sApiStorageV1alpha1VolumeAttachmentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1alpha1VolumeAttachment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeAttachmentList[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeAttachmentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSource.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSource.jl deleted file mode 100644 index a7a3a816..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeAttachmentSource -VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. - - IoK8sApiStorageV1alpha1VolumeAttachmentSource(; - inlineVolumeSpec=nothing, - persistentVolumeName=nothing, - ) - - - inlineVolumeSpec::IoK8sApiCoreV1PersistentVolumeSpec - - persistentVolumeName::String : Name of the persistent volume to attach. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeAttachmentSource <: OpenAPI.APIModel - inlineVolumeSpec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeSpec } - persistentVolumeName::Union{Nothing, String} = nothing - - function IoK8sApiStorageV1alpha1VolumeAttachmentSource(inlineVolumeSpec, persistentVolumeName, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentSource, Symbol("inlineVolumeSpec"), inlineVolumeSpec) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentSource, Symbol("persistentVolumeName"), persistentVolumeName) - return new(inlineVolumeSpec, persistentVolumeName, ) - end -end # type IoK8sApiStorageV1alpha1VolumeAttachmentSource - -const _property_types_IoK8sApiStorageV1alpha1VolumeAttachmentSource = Dict{Symbol,String}(Symbol("inlineVolumeSpec")=>"IoK8sApiCoreV1PersistentVolumeSpec", Symbol("persistentVolumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeAttachmentSource[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeAttachmentSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSpec.jl deleted file mode 100644 index 83379726..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentSpec.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeAttachmentSpec -VolumeAttachmentSpec is the specification of a VolumeAttachment request. - - IoK8sApiStorageV1alpha1VolumeAttachmentSpec(; - attacher=nothing, - nodeName=nothing, - source=nothing, - ) - - - attacher::String : Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). - - nodeName::String : The node that the volume should be attached to. - - source::IoK8sApiStorageV1alpha1VolumeAttachmentSource -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeAttachmentSpec <: OpenAPI.APIModel - attacher::Union{Nothing, String} = nothing - nodeName::Union{Nothing, String} = nothing - source = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1alpha1VolumeAttachmentSource } - - function IoK8sApiStorageV1alpha1VolumeAttachmentSpec(attacher, nodeName, source, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentSpec, Symbol("attacher"), attacher) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentSpec, Symbol("nodeName"), nodeName) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentSpec, Symbol("source"), source) - return new(attacher, nodeName, source, ) - end -end # type IoK8sApiStorageV1alpha1VolumeAttachmentSpec - -const _property_types_IoK8sApiStorageV1alpha1VolumeAttachmentSpec = Dict{Symbol,String}(Symbol("attacher")=>"String", Symbol("nodeName")=>"String", Symbol("source")=>"IoK8sApiStorageV1alpha1VolumeAttachmentSource", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeAttachmentSpec[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeAttachmentSpec) - o.attacher === nothing && (return false) - o.nodeName === nothing && (return false) - o.source === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentStatus.jl deleted file mode 100644 index 54783498..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeAttachmentStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeAttachmentStatus -VolumeAttachmentStatus is the status of a VolumeAttachment request. - - IoK8sApiStorageV1alpha1VolumeAttachmentStatus(; - attachError=nothing, - attached=nothing, - attachmentMetadata=nothing, - detachError=nothing, - ) - - - attachError::IoK8sApiStorageV1alpha1VolumeError - - attached::Bool : Indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - attachmentMetadata::Dict{String, String} : Upon successful attach, this field is populated with any information returned by the attach operation that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - detachError::IoK8sApiStorageV1alpha1VolumeError -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeAttachmentStatus <: OpenAPI.APIModel - attachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1alpha1VolumeError } - attached::Union{Nothing, Bool} = nothing - attachmentMetadata::Union{Nothing, Dict{String, String}} = nothing - detachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1alpha1VolumeError } - - function IoK8sApiStorageV1alpha1VolumeAttachmentStatus(attachError, attached, attachmentMetadata, detachError, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentStatus, Symbol("attachError"), attachError) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentStatus, Symbol("attached"), attached) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentStatus, Symbol("attachmentMetadata"), attachmentMetadata) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeAttachmentStatus, Symbol("detachError"), detachError) - return new(attachError, attached, attachmentMetadata, detachError, ) - end -end # type IoK8sApiStorageV1alpha1VolumeAttachmentStatus - -const _property_types_IoK8sApiStorageV1alpha1VolumeAttachmentStatus = Dict{Symbol,String}(Symbol("attachError")=>"IoK8sApiStorageV1alpha1VolumeError", Symbol("attached")=>"Bool", Symbol("attachmentMetadata")=>"Dict{String, String}", Symbol("detachError")=>"IoK8sApiStorageV1alpha1VolumeError", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeAttachmentStatus[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeAttachmentStatus) - o.attached === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeAttachmentStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeError.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeError.jl deleted file mode 100644 index 449764aa..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1alpha1VolumeError.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1alpha1.VolumeError -VolumeError captures an error encountered during a volume operation. - - IoK8sApiStorageV1alpha1VolumeError(; - message=nothing, - time=nothing, - ) - - - message::String : String detailing the error encountered during Attach or Detach operation. This string maybe logged, so it should not contain sensitive information. - - time::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1alpha1VolumeError <: OpenAPI.APIModel - message::Union{Nothing, String} = nothing - time::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiStorageV1alpha1VolumeError(message, time, ) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeError, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiStorageV1alpha1VolumeError, Symbol("time"), time) - return new(message, time, ) - end -end # type IoK8sApiStorageV1alpha1VolumeError - -const _property_types_IoK8sApiStorageV1alpha1VolumeError = Dict{Symbol,String}(Symbol("message")=>"String", Symbol("time")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1alpha1VolumeError }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1alpha1VolumeError[name]))} - -function check_required(o::IoK8sApiStorageV1alpha1VolumeError) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1alpha1VolumeError }, name::Symbol, val) - if name === Symbol("time") - OpenAPI.validate_param(name, "IoK8sApiStorageV1alpha1VolumeError", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriver.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriver.jl deleted file mode 100644 index 1a911f5b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriver.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSIDriver -CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. CSI drivers do not need to create the CSIDriver object directly. Instead they may use the cluster-driver-registrar sidecar container. When deployed with a CSI driver it automatically creates a CSIDriver object representing the driver. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced. - - IoK8sApiStorageV1beta1CSIDriver(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1beta1CSIDriverSpec -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSIDriver <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1CSIDriverSpec } - - function IoK8sApiStorageV1beta1CSIDriver(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriver, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriver, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriver, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriver, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiStorageV1beta1CSIDriver - -const _property_types_IoK8sApiStorageV1beta1CSIDriver = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1beta1CSIDriverSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSIDriver }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSIDriver[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSIDriver) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSIDriver }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverList.jl deleted file mode 100644 index 3a8b0052..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSIDriverList -CSIDriverList is a collection of CSIDriver objects. - - IoK8sApiStorageV1beta1CSIDriverList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1beta1CSIDriver} : items is the list of CSIDriver - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSIDriverList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1beta1CSIDriver} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1beta1CSIDriverList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1beta1CSIDriverList - -const _property_types_IoK8sApiStorageV1beta1CSIDriverList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1beta1CSIDriver}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSIDriverList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSIDriverList[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSIDriverList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSIDriverList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverSpec.jl deleted file mode 100644 index cc40b997..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSIDriverSpec.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSIDriverSpec -CSIDriverSpec is the specification of a CSIDriver. - - IoK8sApiStorageV1beta1CSIDriverSpec(; - attachRequired=nothing, - podInfoOnMount=nothing, - volumeLifecycleModes=nothing, - ) - - - attachRequired::Bool : attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. - - podInfoOnMount::Bool : If set to true, podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations. If set to false, pod information will not be passed on mount. Default is false. The CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext. The following VolumeConext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \"csi.storage.k8s.io/pod.name\": pod.Name \"csi.storage.k8s.io/pod.namespace\": pod.Namespace \"csi.storage.k8s.io/pod.uid\": string(pod.UID) \"csi.storage.k8s.io/ephemeral\": \"true\" iff the volume is an ephemeral inline volume defined by a CSIVolumeSource, otherwise \"false\" \"csi.storage.k8s.io/ephemeral\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \"Persistent\" and \"Ephemeral\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver. - - volumeLifecycleModes::Vector{String} : VolumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \"Persistent\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism. The other mode is \"Ephemeral\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume. For more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSIDriverSpec <: OpenAPI.APIModel - attachRequired::Union{Nothing, Bool} = nothing - podInfoOnMount::Union{Nothing, Bool} = nothing - volumeLifecycleModes::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiStorageV1beta1CSIDriverSpec(attachRequired, podInfoOnMount, volumeLifecycleModes, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverSpec, Symbol("attachRequired"), attachRequired) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverSpec, Symbol("podInfoOnMount"), podInfoOnMount) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSIDriverSpec, Symbol("volumeLifecycleModes"), volumeLifecycleModes) - return new(attachRequired, podInfoOnMount, volumeLifecycleModes, ) - end -end # type IoK8sApiStorageV1beta1CSIDriverSpec - -const _property_types_IoK8sApiStorageV1beta1CSIDriverSpec = Dict{Symbol,String}(Symbol("attachRequired")=>"Bool", Symbol("podInfoOnMount")=>"Bool", Symbol("volumeLifecycleModes")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSIDriverSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSIDriverSpec[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSIDriverSpec) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSIDriverSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINode.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINode.jl deleted file mode 100644 index dbc294e9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINode.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSINode -DEPRECATED - This group version of CSINode is deprecated by storage/v1/CSINode. See the release notes for more information. CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object. - - IoK8sApiStorageV1beta1CSINode(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1beta1CSINodeSpec -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSINode <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1CSINodeSpec } - - function IoK8sApiStorageV1beta1CSINode(apiVersion, kind, metadata, spec, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINode, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINode, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINode, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINode, Symbol("spec"), spec) - return new(apiVersion, kind, metadata, spec, ) - end -end # type IoK8sApiStorageV1beta1CSINode - -const _property_types_IoK8sApiStorageV1beta1CSINode = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1beta1CSINodeSpec", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSINode }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSINode[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSINode) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSINode }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeDriver.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeDriver.jl deleted file mode 100644 index 78833344..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeDriver.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSINodeDriver -CSINodeDriver holds information about the specification of one CSI driver installed on a node - - IoK8sApiStorageV1beta1CSINodeDriver(; - allocatable=nothing, - name=nothing, - nodeID=nothing, - topologyKeys=nothing, - ) - - - allocatable::IoK8sApiStorageV1beta1VolumeNodeResources - - name::String : This is the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver. - - nodeID::String : nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as \"node1\", but the storage system may refer to the same node as \"nodeA\". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. \"nodeA\" instead of \"node1\". This field is required. - - topologyKeys::Vector{String} : topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. \"company.com/zone\", \"company.com/region\"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSINodeDriver <: OpenAPI.APIModel - allocatable = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeNodeResources } - name::Union{Nothing, String} = nothing - nodeID::Union{Nothing, String} = nothing - topologyKeys::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiStorageV1beta1CSINodeDriver(allocatable, name, nodeID, topologyKeys, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeDriver, Symbol("allocatable"), allocatable) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeDriver, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeDriver, Symbol("nodeID"), nodeID) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeDriver, Symbol("topologyKeys"), topologyKeys) - return new(allocatable, name, nodeID, topologyKeys, ) - end -end # type IoK8sApiStorageV1beta1CSINodeDriver - -const _property_types_IoK8sApiStorageV1beta1CSINodeDriver = Dict{Symbol,String}(Symbol("allocatable")=>"IoK8sApiStorageV1beta1VolumeNodeResources", Symbol("name")=>"String", Symbol("nodeID")=>"String", Symbol("topologyKeys")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSINodeDriver }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSINodeDriver[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSINodeDriver) - o.name === nothing && (return false) - o.nodeID === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSINodeDriver }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeList.jl deleted file mode 100644 index 092d5f57..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSINodeList -CSINodeList is a collection of CSINode objects. - - IoK8sApiStorageV1beta1CSINodeList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1beta1CSINode} : items is the list of CSINode - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSINodeList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1beta1CSINode} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1beta1CSINodeList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1beta1CSINodeList - -const _property_types_IoK8sApiStorageV1beta1CSINodeList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1beta1CSINode}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSINodeList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSINodeList[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSINodeList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSINodeList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeSpec.jl deleted file mode 100644 index 49e48eaf..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1CSINodeSpec.jl +++ /dev/null @@ -1,32 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.CSINodeSpec -CSINodeSpec holds information about the specification of all CSI drivers installed on a node - - IoK8sApiStorageV1beta1CSINodeSpec(; - drivers=nothing, - ) - - - drivers::Vector{IoK8sApiStorageV1beta1CSINodeDriver} : drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1CSINodeSpec <: OpenAPI.APIModel - drivers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1beta1CSINodeDriver} } - - function IoK8sApiStorageV1beta1CSINodeSpec(drivers, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1CSINodeSpec, Symbol("drivers"), drivers) - return new(drivers, ) - end -end # type IoK8sApiStorageV1beta1CSINodeSpec - -const _property_types_IoK8sApiStorageV1beta1CSINodeSpec = Dict{Symbol,String}(Symbol("drivers")=>"Vector{IoK8sApiStorageV1beta1CSINodeDriver}", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1CSINodeSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1CSINodeSpec[name]))} - -function check_required(o::IoK8sApiStorageV1beta1CSINodeSpec) - o.drivers === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1CSINodeSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClass.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClass.jl deleted file mode 100644 index 53ebd8a2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClass.jl +++ /dev/null @@ -1,68 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.StorageClass -StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. - - IoK8sApiStorageV1beta1StorageClass(; - allowVolumeExpansion=nothing, - allowedTopologies=nothing, - apiVersion=nothing, - kind=nothing, - metadata=nothing, - mountOptions=nothing, - parameters=nothing, - provisioner=nothing, - reclaimPolicy=nothing, - volumeBindingMode=nothing, - ) - - - allowVolumeExpansion::Bool : AllowVolumeExpansion shows whether the storage class allow volume expand - - allowedTopologies::Vector{IoK8sApiCoreV1TopologySelectorTerm} : Restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature. - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - mountOptions::Vector{String} : Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid. - - parameters::Dict{String, String} : Parameters holds the parameters for the provisioner that should create volumes of this storage class. - - provisioner::String : Provisioner indicates the type of the provisioner. - - reclaimPolicy::String : Dynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete. - - volumeBindingMode::String : VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1StorageClass <: OpenAPI.APIModel - allowVolumeExpansion::Union{Nothing, Bool} = nothing - allowedTopologies::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiCoreV1TopologySelectorTerm} } - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - mountOptions::Union{Nothing, Vector{String}} = nothing - parameters::Union{Nothing, Dict{String, String}} = nothing - provisioner::Union{Nothing, String} = nothing - reclaimPolicy::Union{Nothing, String} = nothing - volumeBindingMode::Union{Nothing, String} = nothing - - function IoK8sApiStorageV1beta1StorageClass(allowVolumeExpansion, allowedTopologies, apiVersion, kind, metadata, mountOptions, parameters, provisioner, reclaimPolicy, volumeBindingMode, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("allowVolumeExpansion"), allowVolumeExpansion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("allowedTopologies"), allowedTopologies) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("mountOptions"), mountOptions) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("parameters"), parameters) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("provisioner"), provisioner) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("reclaimPolicy"), reclaimPolicy) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClass, Symbol("volumeBindingMode"), volumeBindingMode) - return new(allowVolumeExpansion, allowedTopologies, apiVersion, kind, metadata, mountOptions, parameters, provisioner, reclaimPolicy, volumeBindingMode, ) - end -end # type IoK8sApiStorageV1beta1StorageClass - -const _property_types_IoK8sApiStorageV1beta1StorageClass = Dict{Symbol,String}(Symbol("allowVolumeExpansion")=>"Bool", Symbol("allowedTopologies")=>"Vector{IoK8sApiCoreV1TopologySelectorTerm}", Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("mountOptions")=>"Vector{String}", Symbol("parameters")=>"Dict{String, String}", Symbol("provisioner")=>"String", Symbol("reclaimPolicy")=>"String", Symbol("volumeBindingMode")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1StorageClass }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1StorageClass[name]))} - -function check_required(o::IoK8sApiStorageV1beta1StorageClass) - o.provisioner === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1StorageClass }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClassList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClassList.jl deleted file mode 100644 index 26ec996b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1StorageClassList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.StorageClassList -StorageClassList is a collection of storage classes. - - IoK8sApiStorageV1beta1StorageClassList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1beta1StorageClass} : Items is the list of StorageClasses - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1StorageClassList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1beta1StorageClass} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1beta1StorageClassList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClassList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClassList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClassList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1StorageClassList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1beta1StorageClassList - -const _property_types_IoK8sApiStorageV1beta1StorageClassList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1beta1StorageClass}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1StorageClassList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1StorageClassList[name]))} - -function check_required(o::IoK8sApiStorageV1beta1StorageClassList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1StorageClassList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachment.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachment.jl deleted file mode 100644 index a4b27d13..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachment.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeAttachment -VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced. - - IoK8sApiStorageV1beta1VolumeAttachment(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiStorageV1beta1VolumeAttachmentSpec - - status::IoK8sApiStorageV1beta1VolumeAttachmentStatus -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeAttachment <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeAttachmentSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeAttachmentStatus } - - function IoK8sApiStorageV1beta1VolumeAttachment(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachment, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachment, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachment, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachment, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachment, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiStorageV1beta1VolumeAttachment - -const _property_types_IoK8sApiStorageV1beta1VolumeAttachment = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiStorageV1beta1VolumeAttachmentSpec", Symbol("status")=>"IoK8sApiStorageV1beta1VolumeAttachmentStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeAttachment }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeAttachment[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeAttachment) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeAttachment }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentList.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentList.jl deleted file mode 100644 index 9147d14f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeAttachmentList -VolumeAttachmentList is a collection of VolumeAttachment objects. - - IoK8sApiStorageV1beta1VolumeAttachmentList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiStorageV1beta1VolumeAttachment} : Items is the list of VolumeAttachments - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeAttachmentList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiStorageV1beta1VolumeAttachment} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiStorageV1beta1VolumeAttachmentList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiStorageV1beta1VolumeAttachmentList - -const _property_types_IoK8sApiStorageV1beta1VolumeAttachmentList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiStorageV1beta1VolumeAttachment}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeAttachmentList[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeAttachmentList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSource.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSource.jl deleted file mode 100644 index 6cc9a0b1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSource.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeAttachmentSource -VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. - - IoK8sApiStorageV1beta1VolumeAttachmentSource(; - inlineVolumeSpec=nothing, - persistentVolumeName=nothing, - ) - - - inlineVolumeSpec::IoK8sApiCoreV1PersistentVolumeSpec - - persistentVolumeName::String : Name of the persistent volume to attach. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeAttachmentSource <: OpenAPI.APIModel - inlineVolumeSpec = nothing # spec type: Union{ Nothing, IoK8sApiCoreV1PersistentVolumeSpec } - persistentVolumeName::Union{Nothing, String} = nothing - - function IoK8sApiStorageV1beta1VolumeAttachmentSource(inlineVolumeSpec, persistentVolumeName, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentSource, Symbol("inlineVolumeSpec"), inlineVolumeSpec) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentSource, Symbol("persistentVolumeName"), persistentVolumeName) - return new(inlineVolumeSpec, persistentVolumeName, ) - end -end # type IoK8sApiStorageV1beta1VolumeAttachmentSource - -const _property_types_IoK8sApiStorageV1beta1VolumeAttachmentSource = Dict{Symbol,String}(Symbol("inlineVolumeSpec")=>"IoK8sApiCoreV1PersistentVolumeSpec", Symbol("persistentVolumeName")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentSource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeAttachmentSource[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeAttachmentSource) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentSource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSpec.jl deleted file mode 100644 index 20b4c8c7..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentSpec.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeAttachmentSpec -VolumeAttachmentSpec is the specification of a VolumeAttachment request. - - IoK8sApiStorageV1beta1VolumeAttachmentSpec(; - attacher=nothing, - nodeName=nothing, - source=nothing, - ) - - - attacher::String : Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). - - nodeName::String : The node that the volume should be attached to. - - source::IoK8sApiStorageV1beta1VolumeAttachmentSource -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeAttachmentSpec <: OpenAPI.APIModel - attacher::Union{Nothing, String} = nothing - nodeName::Union{Nothing, String} = nothing - source = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeAttachmentSource } - - function IoK8sApiStorageV1beta1VolumeAttachmentSpec(attacher, nodeName, source, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentSpec, Symbol("attacher"), attacher) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentSpec, Symbol("nodeName"), nodeName) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentSpec, Symbol("source"), source) - return new(attacher, nodeName, source, ) - end -end # type IoK8sApiStorageV1beta1VolumeAttachmentSpec - -const _property_types_IoK8sApiStorageV1beta1VolumeAttachmentSpec = Dict{Symbol,String}(Symbol("attacher")=>"String", Symbol("nodeName")=>"String", Symbol("source")=>"IoK8sApiStorageV1beta1VolumeAttachmentSource", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeAttachmentSpec[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeAttachmentSpec) - o.attacher === nothing && (return false) - o.nodeName === nothing && (return false) - o.source === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentStatus.jl deleted file mode 100644 index 29394b81..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeAttachmentStatus.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeAttachmentStatus -VolumeAttachmentStatus is the status of a VolumeAttachment request. - - IoK8sApiStorageV1beta1VolumeAttachmentStatus(; - attachError=nothing, - attached=nothing, - attachmentMetadata=nothing, - detachError=nothing, - ) - - - attachError::IoK8sApiStorageV1beta1VolumeError - - attached::Bool : Indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - attachmentMetadata::Dict{String, String} : Upon successful attach, this field is populated with any information returned by the attach operation that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. - - detachError::IoK8sApiStorageV1beta1VolumeError -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeAttachmentStatus <: OpenAPI.APIModel - attachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeError } - attached::Union{Nothing, Bool} = nothing - attachmentMetadata::Union{Nothing, Dict{String, String}} = nothing - detachError = nothing # spec type: Union{ Nothing, IoK8sApiStorageV1beta1VolumeError } - - function IoK8sApiStorageV1beta1VolumeAttachmentStatus(attachError, attached, attachmentMetadata, detachError, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentStatus, Symbol("attachError"), attachError) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentStatus, Symbol("attached"), attached) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentStatus, Symbol("attachmentMetadata"), attachmentMetadata) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeAttachmentStatus, Symbol("detachError"), detachError) - return new(attachError, attached, attachmentMetadata, detachError, ) - end -end # type IoK8sApiStorageV1beta1VolumeAttachmentStatus - -const _property_types_IoK8sApiStorageV1beta1VolumeAttachmentStatus = Dict{Symbol,String}(Symbol("attachError")=>"IoK8sApiStorageV1beta1VolumeError", Symbol("attached")=>"Bool", Symbol("attachmentMetadata")=>"Dict{String, String}", Symbol("detachError")=>"IoK8sApiStorageV1beta1VolumeError", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeAttachmentStatus[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeAttachmentStatus) - o.attached === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeAttachmentStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeError.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeError.jl deleted file mode 100644 index 2b004609..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeError.jl +++ /dev/null @@ -1,38 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeError -VolumeError captures an error encountered during a volume operation. - - IoK8sApiStorageV1beta1VolumeError(; - message=nothing, - time=nothing, - ) - - - message::String : String detailing the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information. - - time::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeError <: OpenAPI.APIModel - message::Union{Nothing, String} = nothing - time::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApiStorageV1beta1VolumeError(message, time, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeError, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeError, Symbol("time"), time) - return new(message, time, ) - end -end # type IoK8sApiStorageV1beta1VolumeError - -const _property_types_IoK8sApiStorageV1beta1VolumeError = Dict{Symbol,String}(Symbol("message")=>"String", Symbol("time")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeError }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeError[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeError) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeError }, name::Symbol, val) - if name === Symbol("time") - OpenAPI.validate_param(name, "IoK8sApiStorageV1beta1VolumeError", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeNodeResources.jl b/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeNodeResources.jl deleted file mode 100644 index 994559b2..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiStorageV1beta1VolumeNodeResources.jl +++ /dev/null @@ -1,34 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.api.storage.v1beta1.VolumeNodeResources -VolumeNodeResources is a set of resource limits for scheduling of volumes. - - IoK8sApiStorageV1beta1VolumeNodeResources(; - count=nothing, - ) - - - count::Int64 : Maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is nil, then the supported number of volumes on this node is unbounded. -""" -Base.@kwdef mutable struct IoK8sApiStorageV1beta1VolumeNodeResources <: OpenAPI.APIModel - count::Union{Nothing, Int64} = nothing - - function IoK8sApiStorageV1beta1VolumeNodeResources(count, ) - OpenAPI.validate_property(IoK8sApiStorageV1beta1VolumeNodeResources, Symbol("count"), count) - return new(count, ) - end -end # type IoK8sApiStorageV1beta1VolumeNodeResources - -const _property_types_IoK8sApiStorageV1beta1VolumeNodeResources = Dict{Symbol,String}(Symbol("count")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiStorageV1beta1VolumeNodeResources }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiStorageV1beta1VolumeNodeResources[name]))} - -function check_required(o::IoK8sApiStorageV1beta1VolumeNodeResources) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiStorageV1beta1VolumeNodeResources }, name::Symbol, val) - if name === Symbol("count") - OpenAPI.validate_param(name, "IoK8sApiStorageV1beta1VolumeNodeResources", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition.jl deleted file mode 100644 index f3d20a40..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition.jl +++ /dev/null @@ -1,57 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition -CustomResourceColumnDefinition specifies a column for server side printing. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition(; - description=nothing, - format=nothing, - jsonPath=nothing, - name=nothing, - priority=nothing, - type=nothing, - ) - - - description::String : description is a human readable description of this column. - - format::String : format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. - - jsonPath::String : jsonPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column. - - name::String : name is a human readable name for the column. - - priority::Int64 : priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0. - - type::String : type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition <: OpenAPI.APIModel - description::Union{Nothing, String} = nothing - format::Union{Nothing, String} = nothing - jsonPath::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - priority::Union{Nothing, Int64} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition(description, format, jsonPath, name, priority, type, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("format"), format) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("jsonPath"), jsonPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("priority"), priority) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, Symbol("type"), type) - return new(description, format, jsonPath, name, priority, type, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition = Dict{Symbol,String}(Symbol("description")=>"String", Symbol("format")=>"String", Symbol("jsonPath")=>"String", Symbol("name")=>"String", Symbol("priority")=>"Int64", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition) - o.jsonPath === nothing && (return false) - o.name === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition }, name::Symbol, val) - if name === Symbol("priority") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion.jl deleted file mode 100644 index 2178d5a4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion -CustomResourceConversion describes how to convert different versions of a CR. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion(; - strategy=nothing, - webhook=nothing, - ) - - - strategy::String : strategy specifies how custom resources are converted between versions. Allowed values are: - `None`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `Webhook`: API Server will call to an external webhook to do the conversion. Additional information is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set. - - webhook::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion <: OpenAPI.APIModel - strategy::Union{Nothing, String} = nothing - webhook = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion(strategy, webhook, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion, Symbol("webhook"), webhook) - return new(strategy, webhook, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion = Dict{Symbol,String}(Symbol("strategy")=>"String", Symbol("webhook")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion) - o.strategy === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition.jl deleted file mode 100644 index fbd19a60..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition -CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec - - status::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec", Symbol("status")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition.jl deleted file mode 100644 index 030fd7a3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition -CustomResourceDefinitionCondition contains details for the current condition of this pod. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : message is a human-readable message indicating details about last transition. - - reason::String : reason is a unique, one-word, CamelCase reason for the condition's last transition. - - status::String : status is the status of the condition. Can be True, False, Unknown. - - type::String : type is the type of the condition. Types include Established, NamesAccepted and Terminating. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList.jl deleted file mode 100644 index 0f0cb02b..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList -CustomResourceDefinitionList is a list of CustomResourceDefinition objects. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition} : items list individual CustomResourceDefinition objects - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames.jl deleted file mode 100644 index 3cf4a214..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames -CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames(; - categories=nothing, - kind=nothing, - listKind=nothing, - plural=nothing, - shortNames=nothing, - singular=nothing, - ) - - - categories::Vector{String} : categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. - - kind::String : kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls. - - listKind::String : listKind is the serialized kind of the list for this resource. Defaults to \"`kind`List\". - - plural::String : plural is the plural name of the resource to serve. The custom resources are served under `/apis/<group>/<version>/.../<plural>`. Must match the name of the CustomResourceDefinition (in the form `<names.plural>.<group>`). Must be all lowercase. - - shortNames::Vector{String} : shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get <shortname>`. It must be all lowercase. - - singular::String : singular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames <: OpenAPI.APIModel - categories::Union{Nothing, Vector{String}} = nothing - kind::Union{Nothing, String} = nothing - listKind::Union{Nothing, String} = nothing - plural::Union{Nothing, String} = nothing - shortNames::Union{Nothing, Vector{String}} = nothing - singular::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames(categories, kind, listKind, plural, shortNames, singular, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("categories"), categories) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("listKind"), listKind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("plural"), plural) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("shortNames"), shortNames) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, Symbol("singular"), singular) - return new(categories, kind, listKind, plural, shortNames, singular, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames = Dict{Symbol,String}(Symbol("categories")=>"Vector{String}", Symbol("kind")=>"String", Symbol("listKind")=>"String", Symbol("plural")=>"String", Symbol("shortNames")=>"Vector{String}", Symbol("singular")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames) - o.kind === nothing && (return false) - o.plural === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec.jl deleted file mode 100644 index 5a72b78a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec -CustomResourceDefinitionSpec describes how a user wants their resource to appear - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec(; - conversion=nothing, - group=nothing, - names=nothing, - preserveUnknownFields=nothing, - scope=nothing, - versions=nothing, - ) - - - conversion::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion - - group::String : group is the API group of the defined custom resource. The custom resources are served under `/apis/<group>/...`. Must match the name of the CustomResourceDefinition (in the form `<names.plural>.<group>`). - - names::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames - - preserveUnknownFields::Bool : preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/#pruning-versus-preserving-unknown-fields for details. - - scope::String : scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`. - - versions::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion} : versions is the list of all API versions of the defined custom resource. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec <: OpenAPI.APIModel - conversion = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion } - group::Union{Nothing, String} = nothing - names = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames } - preserveUnknownFields::Union{Nothing, Bool} = nothing - scope::Union{Nothing, String} = nothing - versions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion} } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec(conversion, group, names, preserveUnknownFields, scope, versions, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("conversion"), conversion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("names"), names) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("preserveUnknownFields"), preserveUnknownFields) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("scope"), scope) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, Symbol("versions"), versions) - return new(conversion, group, names, preserveUnknownFields, scope, versions, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec = Dict{Symbol,String}(Symbol("conversion")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion", Symbol("group")=>"String", Symbol("names")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames", Symbol("preserveUnknownFields")=>"Bool", Symbol("scope")=>"String", Symbol("versions")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion}", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec) - o.group === nothing && (return false) - o.names === nothing && (return false) - o.scope === nothing && (return false) - o.versions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus.jl deleted file mode 100644 index 84a2d579..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus -CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus(; - acceptedNames=nothing, - conditions=nothing, - storedVersions=nothing, - ) - - - acceptedNames::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames - - conditions::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition} : conditions indicate state for particular aspects of a CustomResourceDefinition - - storedVersions::Vector{String} : storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus <: OpenAPI.APIModel - acceptedNames = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames } - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition} } - storedVersions::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus(acceptedNames, conditions, storedVersions, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus, Symbol("acceptedNames"), acceptedNames) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus, Symbol("storedVersions"), storedVersions) - return new(acceptedNames, conditions, storedVersions, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus = Dict{Symbol,String}(Symbol("acceptedNames")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames", Symbol("conditions")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition}", Symbol("storedVersions")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus) - o.acceptedNames === nothing && (return false) - o.storedVersions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion.jl deleted file mode 100644 index 57414a1d..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion -CustomResourceDefinitionVersion describes a version for CRD. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion(; - additionalPrinterColumns=nothing, - name=nothing, - schema=nothing, - served=nothing, - storage=nothing, - subresources=nothing, - ) - - - additionalPrinterColumns::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition} : additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used. - - name::String : name is the version name, e.g. “v1”, “v2beta1”, etc. The custom resources are served under this version at `/apis/<group>/<version>/...` if `served` is true. - - schema::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation - - served::Bool : served is a flag enabling/disabling this version from being served via REST APIs - - storage::Bool : storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true. - - subresources::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion <: OpenAPI.APIModel - additionalPrinterColumns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition} } - name::Union{Nothing, String} = nothing - schema = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation } - served::Union{Nothing, Bool} = nothing - storage::Union{Nothing, Bool} = nothing - subresources = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion(additionalPrinterColumns, name, schema, served, storage, subresources, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("additionalPrinterColumns"), additionalPrinterColumns) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("schema"), schema) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("served"), served) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("storage"), storage) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, Symbol("subresources"), subresources) - return new(additionalPrinterColumns, name, schema, served, storage, subresources, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion = Dict{Symbol,String}(Symbol("additionalPrinterColumns")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition}", Symbol("name")=>"String", Symbol("schema")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation", Symbol("served")=>"Bool", Symbol("storage")=>"Bool", Symbol("subresources")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion) - o.name === nothing && (return false) - o.served === nothing && (return false) - o.storage === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale.jl deleted file mode 100644 index 5984768f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale -CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale(; - labelSelectorPath=nothing, - specReplicasPath=nothing, - statusReplicasPath=nothing, - ) - - - labelSelectorPath::String : labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. - - specReplicasPath::String : specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET. - - statusReplicasPath::String : statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale <: OpenAPI.APIModel - labelSelectorPath::Union{Nothing, String} = nothing - specReplicasPath::Union{Nothing, String} = nothing - statusReplicasPath::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale(labelSelectorPath, specReplicasPath, statusReplicasPath, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale, Symbol("labelSelectorPath"), labelSelectorPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale, Symbol("specReplicasPath"), specReplicasPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale, Symbol("statusReplicasPath"), statusReplicasPath) - return new(labelSelectorPath, specReplicasPath, statusReplicasPath, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale = Dict{Symbol,String}(Symbol("labelSelectorPath")=>"String", Symbol("specReplicasPath")=>"String", Symbol("statusReplicasPath")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale) - o.specReplicasPath === nothing && (return false) - o.statusReplicasPath === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources.jl deleted file mode 100644 index a265f47a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources -CustomResourceSubresources defines the status and scale subresources for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources(; - scale=nothing, - status=nothing, - ) - - - scale::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale - - status::Any : CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources <: OpenAPI.APIModel - scale = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale } - status::Union{Nothing, Any} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources(scale, status, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources, Symbol("scale"), scale) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources, Symbol("status"), status) - return new(scale, status, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources = Dict{Symbol,String}(Symbol("scale")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale", Symbol("status")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation.jl deleted file mode 100644 index 4ba68390..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation -CustomResourceValidation is a list of validation methods for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation(; - openAPIV3Schema=nothing, - ) - - - openAPIV3Schema::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation <: OpenAPI.APIModel - openAPIV3Schema = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation(openAPIV3Schema, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation, Symbol("openAPIV3Schema"), openAPIV3Schema) - return new(openAPIV3Schema, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation = Dict{Symbol,String}(Symbol("openAPIV3Schema")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation.jl deleted file mode 100644 index aab79108..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation -ExternalDocumentation allows referencing an external resource for extended documentation. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation(; - description=nothing, - url=nothing, - ) - - - description::String - - url::String -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation <: OpenAPI.APIModel - description::Union{Nothing, String} = nothing - url::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation(description, url, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation, Symbol("url"), url) - return new(description, url, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation = Dict{Symbol,String}(Symbol("description")=>"String", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps.jl deleted file mode 100644 index 3f495409..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps.jl +++ /dev/null @@ -1,226 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps -JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps(; - var"$ref"=nothing, - var"$schema"=nothing, - additionalItems=nothing, - additionalProperties=nothing, - allOf=nothing, - anyOf=nothing, - default=nothing, - definitions=nothing, - dependencies=nothing, - description=nothing, - enum=nothing, - example=nothing, - exclusiveMaximum=nothing, - exclusiveMinimum=nothing, - externalDocs=nothing, - format=nothing, - id=nothing, - items=nothing, - maxItems=nothing, - maxLength=nothing, - maxProperties=nothing, - maximum=nothing, - minItems=nothing, - minLength=nothing, - minProperties=nothing, - minimum=nothing, - multipleOf=nothing, - not=nothing, - nullable=nothing, - oneOf=nothing, - pattern=nothing, - patternProperties=nothing, - properties=nothing, - required=nothing, - title=nothing, - type=nothing, - uniqueItems=nothing, - var"x-kubernetes-embedded-resource"=nothing, - var"x-kubernetes-int-or-string"=nothing, - var"x-kubernetes-list-map-keys"=nothing, - var"x-kubernetes-list-type"=nothing, - var"x-kubernetes-map-type"=nothing, - var"x-kubernetes-preserve-unknown-fields"=nothing, - ) - - - var"$ref"::String - - var"$schema"::String - - additionalItems::Any : JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property. - - additionalProperties::Any : JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property. - - allOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - anyOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - default::Any : JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. - - definitions::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - dependencies::Dict{String, Any} - - description::String - - enum::Vector{Any} - - example::Any : JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. - - exclusiveMaximum::Bool - - exclusiveMinimum::Bool - - externalDocs::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation - - format::String : format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated: - bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like \"0321751043\" or \"978-0321751041\" - isbn10: an ISBN10 number string like \"0321751043\" - isbn13: an ISBN13 number string like \"978-0321751041\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\d{3}[- ]?\\d{2}[- ]?\\d{4}$ - hexcolor: an hexadecimal color code like \"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like \"rgb(255,255,2559\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \"2006-01-02\" as defined by full-date in RFC3339 - duration: a duration string like \"22 ns\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \"2014-12-15T19:30:20.000Z\" as defined by date-time in RFC3339. - - id::String - - items::Any : JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes. - - maxItems::Int64 - - maxLength::Int64 - - maxProperties::Int64 - - maximum::Float64 - - minItems::Int64 - - minLength::Int64 - - minProperties::Int64 - - minimum::Float64 - - multipleOf::Float64 - - not::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps - - nullable::Bool - - oneOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - pattern::String - - patternProperties::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - properties::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} - - required::Vector{String} - - title::String - - type::String - - uniqueItems::Bool - - var"x-kubernetes-embedded-resource"::Bool : x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata). - - var"x-kubernetes-int-or-string"::Bool : x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns: 1) anyOf: - type: integer - type: string 2) allOf: - anyOf: - type: integer - type: string - ... zero or more - - var"x-kubernetes-list-map-keys"::Vector{String} : x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map. This tag MUST only be used on lists that have the \"x-kubernetes-list-type\" extension set to \"map\". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported). - - var"x-kubernetes-list-type"::String : x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values: 1) `atomic`: the list is treated as a single entity, like a scalar. Atomic lists will be entirely replaced when updated. This extension may be used on any type of list (struct, scalar, ...). 2) `set`: Sets are lists that must not have multiple items with the same value. Each value must be a scalar, an object with x-kubernetes-map-type `atomic` or an array with x-kubernetes-list-type `atomic`. 3) `map`: These lists are like maps in that their elements have a non-index key used to identify them. Order is preserved upon merge. The map tag must only be used on a list with elements of type object. Defaults to atomic for arrays. - - var"x-kubernetes-map-type"::String : x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values: 1) `granular`: These maps are actual maps (key-value pairs) and each fields are independent from each other (they can each be manipulated by separate actors). This is the default behaviour for all maps. 2) `atomic`: the list is treated as a single entity, like a scalar. Atomic maps will be entirely replaced when updated. - - var"x-kubernetes-preserve-unknown-fields"::Bool : x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps <: OpenAPI.APIModel - var"$ref"::Union{Nothing, String} = nothing - var"$schema"::Union{Nothing, String} = nothing - additionalItems::Union{Nothing, Any} = nothing - additionalProperties::Union{Nothing, Any} = nothing - allOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - anyOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - default::Union{Nothing, Any} = nothing - definitions::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - dependencies::Union{Nothing, Dict{String, Any}} = nothing - description::Union{Nothing, String} = nothing - enum::Union{Nothing, Vector{Any}} = nothing - example::Union{Nothing, Any} = nothing - exclusiveMaximum::Union{Nothing, Bool} = nothing - exclusiveMinimum::Union{Nothing, Bool} = nothing - externalDocs = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation } - format::Union{Nothing, String} = nothing - id::Union{Nothing, String} = nothing - items::Union{Nothing, Any} = nothing - maxItems::Union{Nothing, Int64} = nothing - maxLength::Union{Nothing, Int64} = nothing - maxProperties::Union{Nothing, Int64} = nothing - maximum::Union{Nothing, Float64} = nothing - minItems::Union{Nothing, Int64} = nothing - minLength::Union{Nothing, Int64} = nothing - minProperties::Union{Nothing, Int64} = nothing - minimum::Union{Nothing, Float64} = nothing - multipleOf::Union{Nothing, Float64} = nothing - not = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps } - nullable::Union{Nothing, Bool} = nothing - oneOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - pattern::Union{Nothing, String} = nothing - patternProperties::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - properties::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps} } - required::Union{Nothing, Vector{String}} = nothing - title::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - uniqueItems::Union{Nothing, Bool} = nothing - var"x-kubernetes-embedded-resource"::Union{Nothing, Bool} = nothing - var"x-kubernetes-int-or-string"::Union{Nothing, Bool} = nothing - var"x-kubernetes-list-map-keys"::Union{Nothing, Vector{String}} = nothing - var"x-kubernetes-list-type"::Union{Nothing, String} = nothing - var"x-kubernetes-map-type"::Union{Nothing, String} = nothing - var"x-kubernetes-preserve-unknown-fields"::Union{Nothing, Bool} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps(var"$ref", var"$schema", additionalItems, additionalProperties, allOf, anyOf, default, definitions, dependencies, description, enum, example, exclusiveMaximum, exclusiveMinimum, externalDocs, format, id, items, maxItems, maxLength, maxProperties, maximum, minItems, minLength, minProperties, minimum, multipleOf, not, nullable, oneOf, pattern, patternProperties, properties, required, title, type, uniqueItems, var"x-kubernetes-embedded-resource", var"x-kubernetes-int-or-string", var"x-kubernetes-list-map-keys", var"x-kubernetes-list-type", var"x-kubernetes-map-type", var"x-kubernetes-preserve-unknown-fields", ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("\$ref"), var"$ref") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("\$schema"), var"$schema") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("additionalItems"), additionalItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("additionalProperties"), additionalProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("allOf"), allOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("anyOf"), anyOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("default"), default) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("definitions"), definitions) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("dependencies"), dependencies) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("enum"), enum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("example"), example) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("exclusiveMaximum"), exclusiveMaximum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("exclusiveMinimum"), exclusiveMinimum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("externalDocs"), externalDocs) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("format"), format) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("id"), id) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("maxItems"), maxItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("maxLength"), maxLength) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("maxProperties"), maxProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("maximum"), maximum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("minItems"), minItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("minLength"), minLength) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("minProperties"), minProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("minimum"), minimum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("multipleOf"), multipleOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("not"), not) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("nullable"), nullable) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("oneOf"), oneOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("pattern"), pattern) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("patternProperties"), patternProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("properties"), properties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("required"), required) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("title"), title) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("type"), type) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("uniqueItems"), uniqueItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-embedded-resource"), var"x-kubernetes-embedded-resource") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-int-or-string"), var"x-kubernetes-int-or-string") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-list-map-keys"), var"x-kubernetes-list-map-keys") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-list-type"), var"x-kubernetes-list-type") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-map-type"), var"x-kubernetes-map-type") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, Symbol("x-kubernetes-preserve-unknown-fields"), var"x-kubernetes-preserve-unknown-fields") - return new(var"$ref", var"$schema", additionalItems, additionalProperties, allOf, anyOf, default, definitions, dependencies, description, enum, example, exclusiveMaximum, exclusiveMinimum, externalDocs, format, id, items, maxItems, maxLength, maxProperties, maximum, minItems, minLength, minProperties, minimum, multipleOf, not, nullable, oneOf, pattern, patternProperties, properties, required, title, type, uniqueItems, var"x-kubernetes-embedded-resource", var"x-kubernetes-int-or-string", var"x-kubernetes-list-map-keys", var"x-kubernetes-list-type", var"x-kubernetes-map-type", var"x-kubernetes-preserve-unknown-fields", ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps = Dict{Symbol,String}(Symbol("\$ref")=>"String", Symbol("\$schema")=>"String", Symbol("additionalItems")=>"Any", Symbol("additionalProperties")=>"Any", Symbol("allOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("anyOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("default")=>"Any", Symbol("definitions")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("dependencies")=>"Dict{String, Any}", Symbol("description")=>"String", Symbol("enum")=>"Vector{Any}", Symbol("example")=>"Any", Symbol("exclusiveMaximum")=>"Bool", Symbol("exclusiveMinimum")=>"Bool", Symbol("externalDocs")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation", Symbol("format")=>"String", Symbol("id")=>"String", Symbol("items")=>"Any", Symbol("maxItems")=>"Int64", Symbol("maxLength")=>"Int64", Symbol("maxProperties")=>"Int64", Symbol("maximum")=>"Float64", Symbol("minItems")=>"Int64", Symbol("minLength")=>"Int64", Symbol("minProperties")=>"Int64", Symbol("minimum")=>"Float64", Symbol("multipleOf")=>"Float64", Symbol("not")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", Symbol("nullable")=>"Bool", Symbol("oneOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("pattern")=>"String", Symbol("patternProperties")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("properties")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}", Symbol("required")=>"Vector{String}", Symbol("title")=>"String", Symbol("type")=>"String", Symbol("uniqueItems")=>"Bool", Symbol("x-kubernetes-embedded-resource")=>"Bool", Symbol("x-kubernetes-int-or-string")=>"Bool", Symbol("x-kubernetes-list-map-keys")=>"Vector{String}", Symbol("x-kubernetes-list-type")=>"String", Symbol("x-kubernetes-map-type")=>"String", Symbol("x-kubernetes-preserve-unknown-fields")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps }, name::Symbol, val) - if name === Symbol("maxItems") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maxLength") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maxProperties") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maximum") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "double") - end - if name === Symbol("minItems") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minLength") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minProperties") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minimum") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "double") - end - if name === Symbol("multipleOf") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps", :format, val, "double") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference.jl deleted file mode 100644 index 26ffae34..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference(; - name=nothing, - namespace=nothing, - path=nothing, - port=nothing, - ) - - - name::String : name is the name of the service. Required - - namespace::String : namespace is the namespace of the service. Required - - path::String : path is an optional URL path at which the webhook will be contacted. - - port::Int64 : port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference(name, namespace, path, port, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference, Symbol("port"), port) - return new(name, namespace, path, port, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("path")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig.jl deleted file mode 100644 index 792a7667..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig -WebhookClientConfig contains the information to make a TLS connection with the webhook. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig(; - caBundle=nothing, - service=nothing, - url=nothing, - ) - - - caBundle::Vector{UInt8} : caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. - - service::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference - - url::String : url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference } - url::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig(caBundle, service, url, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig, Symbol("service"), service) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig, Symbol("url"), url) - return new(caBundle, service, url, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("service")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion.jl deleted file mode 100644 index 5c1f7952..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion.jl +++ /dev/null @@ -1,36 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion -WebhookConversion describes how to call a conversion webhook - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion(; - clientConfig=nothing, - conversionReviewVersions=nothing, - ) - - - clientConfig::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig - - conversionReviewVersions::Vector{String} : conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion <: OpenAPI.APIModel - clientConfig = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig } - conversionReviewVersions::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion(clientConfig, conversionReviewVersions, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion, Symbol("clientConfig"), clientConfig) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion, Symbol("conversionReviewVersions"), conversionReviewVersions) - return new(clientConfig, conversionReviewVersions, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion = Dict{Symbol,String}(Symbol("clientConfig")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig", Symbol("conversionReviewVersions")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion) - o.conversionReviewVersions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition.jl deleted file mode 100644 index c6c587a4..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition.jl +++ /dev/null @@ -1,57 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceColumnDefinition -CustomResourceColumnDefinition specifies a column for server side printing. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition(; - JSONPath=nothing, - description=nothing, - format=nothing, - name=nothing, - priority=nothing, - type=nothing, - ) - - - JSONPath::String : JSONPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column. - - description::String : description is a human readable description of this column. - - format::String : format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. - - name::String : name is a human readable name for the column. - - priority::Int64 : priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0. - - type::String : type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition <: OpenAPI.APIModel - JSONPath::Union{Nothing, String} = nothing - description::Union{Nothing, String} = nothing - format::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - priority::Union{Nothing, Int64} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition(JSONPath, description, format, name, priority, type, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("JSONPath"), JSONPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("format"), format) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("priority"), priority) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition, Symbol("type"), type) - return new(JSONPath, description, format, name, priority, type, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition = Dict{Symbol,String}(Symbol("JSONPath")=>"String", Symbol("description")=>"String", Symbol("format")=>"String", Symbol("name")=>"String", Symbol("priority")=>"Int64", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition) - o.JSONPath === nothing && (return false) - o.name === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition }, name::Symbol, val) - if name === Symbol("priority") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion.jl deleted file mode 100644 index be2d382c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceConversion -CustomResourceConversion describes how to convert different versions of a CR. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion(; - conversionReviewVersions=nothing, - strategy=nothing, - webhookClientConfig=nothing, - ) - - - conversionReviewVersions::Vector{String} : conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail. Defaults to `[\"v1beta1\"]`. - - strategy::String : strategy specifies how custom resources are converted between versions. Allowed values are: - `None`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `Webhook`: API Server will call to an external webhook to do the conversion. Additional information is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhookClientConfig to be set. - - webhookClientConfig::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion <: OpenAPI.APIModel - conversionReviewVersions::Union{Nothing, Vector{String}} = nothing - strategy::Union{Nothing, String} = nothing - webhookClientConfig = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion(conversionReviewVersions, strategy, webhookClientConfig, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion, Symbol("conversionReviewVersions"), conversionReviewVersions) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion, Symbol("strategy"), strategy) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion, Symbol("webhookClientConfig"), webhookClientConfig) - return new(conversionReviewVersions, strategy, webhookClientConfig, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion = Dict{Symbol,String}(Symbol("conversionReviewVersions")=>"Vector{String}", Symbol("strategy")=>"String", Symbol("webhookClientConfig")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion) - o.strategy === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition.jl deleted file mode 100644 index bd6cd873..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinition -CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>. Deprecated in v1.16, planned for removal in v1.19. Use apiextensions.k8s.io/v1 CustomResourceDefinition instead. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec - - status::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec } - status = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec", Symbol("status")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition) - o.spec === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition.jl deleted file mode 100644 index ec3bd079..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionCondition -CustomResourceDefinitionCondition contains details for the current condition of this pod. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : message is a human-readable message indicating details about last transition. - - reason::String : reason is a unique, one-word, CamelCase reason for the condition's last transition. - - status::String : status is the status of the condition. Can be True, False, Unknown. - - type::String : type is the type of the condition. Types include Established, NamesAccepted and Terminating. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList.jl deleted file mode 100644 index 476db669..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionList -CustomResourceDefinitionList is a list of CustomResourceDefinition objects. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition} : items list individual CustomResourceDefinition objects - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames.jl deleted file mode 100644 index fbe9030a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionNames -CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames(; - categories=nothing, - kind=nothing, - listKind=nothing, - plural=nothing, - shortNames=nothing, - singular=nothing, - ) - - - categories::Vector{String} : categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. - - kind::String : kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls. - - listKind::String : listKind is the serialized kind of the list for this resource. Defaults to \"`kind`List\". - - plural::String : plural is the plural name of the resource to serve. The custom resources are served under `/apis/<group>/<version>/.../<plural>`. Must match the name of the CustomResourceDefinition (in the form `<names.plural>.<group>`). Must be all lowercase. - - shortNames::Vector{String} : shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get <shortname>`. It must be all lowercase. - - singular::String : singular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames <: OpenAPI.APIModel - categories::Union{Nothing, Vector{String}} = nothing - kind::Union{Nothing, String} = nothing - listKind::Union{Nothing, String} = nothing - plural::Union{Nothing, String} = nothing - shortNames::Union{Nothing, Vector{String}} = nothing - singular::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames(categories, kind, listKind, plural, shortNames, singular, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("categories"), categories) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("listKind"), listKind) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("plural"), plural) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("shortNames"), shortNames) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames, Symbol("singular"), singular) - return new(categories, kind, listKind, plural, shortNames, singular, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames = Dict{Symbol,String}(Symbol("categories")=>"Vector{String}", Symbol("kind")=>"String", Symbol("listKind")=>"String", Symbol("plural")=>"String", Symbol("shortNames")=>"Vector{String}", Symbol("singular")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames) - o.kind === nothing && (return false) - o.plural === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec.jl deleted file mode 100644 index 797622c6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionSpec -CustomResourceDefinitionSpec describes how a user wants their resource to appear - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec(; - additionalPrinterColumns=nothing, - conversion=nothing, - group=nothing, - names=nothing, - preserveUnknownFields=nothing, - scope=nothing, - subresources=nothing, - validation=nothing, - version=nothing, - versions=nothing, - ) - - - additionalPrinterColumns::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition} : additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If present, this field configures columns for all versions. Top-level and per-version columns are mutually exclusive. If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. - - conversion::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion - - group::String : group is the API group of the defined custom resource. The custom resources are served under `/apis/<group>/...`. Must match the name of the CustomResourceDefinition (in the form `<names.plural>.<group>`). - - names::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames - - preserveUnknownFields::Bool : preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. If false, schemas must be defined for all versions. Defaults to true in v1beta for backwards compatibility. Deprecated: will be required to be false in v1. Preservation of unknown fields can be specified in the validation schema using the `x-kubernetes-preserve-unknown-fields: true` extension. See https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/#pruning-versus-preserving-unknown-fields for details. - - scope::String : scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`. Default is `Namespaced`. - - subresources::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources - - validation::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation - - version::String : version is the API version of the defined custom resource. The custom resources are served under `/apis/<group>/<version>/...`. Must match the name of the first item in the `versions` list if `version` and `versions` are both specified. Optional if `versions` is specified. Deprecated: use `versions` instead. - - versions::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion} : versions is the list of all API versions of the defined custom resource. Optional if `version` is specified. The name of the first item in the `versions` list must match the `version` field if `version` and `versions` are both specified. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec <: OpenAPI.APIModel - additionalPrinterColumns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition} } - conversion = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion } - group::Union{Nothing, String} = nothing - names = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames } - preserveUnknownFields::Union{Nothing, Bool} = nothing - scope::Union{Nothing, String} = nothing - subresources = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources } - validation = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation } - version::Union{Nothing, String} = nothing - versions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion} } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec(additionalPrinterColumns, conversion, group, names, preserveUnknownFields, scope, subresources, validation, version, versions, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("additionalPrinterColumns"), additionalPrinterColumns) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("conversion"), conversion) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("names"), names) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("preserveUnknownFields"), preserveUnknownFields) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("scope"), scope) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("subresources"), subresources) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("validation"), validation) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("version"), version) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec, Symbol("versions"), versions) - return new(additionalPrinterColumns, conversion, group, names, preserveUnknownFields, scope, subresources, validation, version, versions, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec = Dict{Symbol,String}(Symbol("additionalPrinterColumns")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition}", Symbol("conversion")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion", Symbol("group")=>"String", Symbol("names")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames", Symbol("preserveUnknownFields")=>"Bool", Symbol("scope")=>"String", Symbol("subresources")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources", Symbol("validation")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation", Symbol("version")=>"String", Symbol("versions")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion}", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec) - o.group === nothing && (return false) - o.names === nothing && (return false) - o.scope === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus.jl deleted file mode 100644 index 94f9bc1a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionStatus -CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus(; - acceptedNames=nothing, - conditions=nothing, - storedVersions=nothing, - ) - - - acceptedNames::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames - - conditions::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition} : conditions indicate state for particular aspects of a CustomResourceDefinition - - storedVersions::Vector{String} : storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus <: OpenAPI.APIModel - acceptedNames = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames } - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition} } - storedVersions::Union{Nothing, Vector{String}} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus(acceptedNames, conditions, storedVersions, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus, Symbol("acceptedNames"), acceptedNames) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus, Symbol("storedVersions"), storedVersions) - return new(acceptedNames, conditions, storedVersions, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus = Dict{Symbol,String}(Symbol("acceptedNames")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames", Symbol("conditions")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition}", Symbol("storedVersions")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus) - o.acceptedNames === nothing && (return false) - o.storedVersions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion.jl deleted file mode 100644 index 397c6fd1..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionVersion -CustomResourceDefinitionVersion describes a version for CRD. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion(; - additionalPrinterColumns=nothing, - name=nothing, - schema=nothing, - served=nothing, - storage=nothing, - subresources=nothing, - ) - - - additionalPrinterColumns::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition} : additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. Top-level and per-version columns are mutually exclusive. Per-version columns must not all be set to identical values (top-level columns should be used instead). If no top-level or per-version columns are specified, a single column displaying the age of the custom resource is used. - - name::String : name is the version name, e.g. “v1”, “v2beta1”, etc. The custom resources are served under this version at `/apis/<group>/<version>/...` if `served` is true. - - schema::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation - - served::Bool : served is a flag enabling/disabling this version from being served via REST APIs - - storage::Bool : storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true. - - subresources::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion <: OpenAPI.APIModel - additionalPrinterColumns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition} } - name::Union{Nothing, String} = nothing - schema = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation } - served::Union{Nothing, Bool} = nothing - storage::Union{Nothing, Bool} = nothing - subresources = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion(additionalPrinterColumns, name, schema, served, storage, subresources, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("additionalPrinterColumns"), additionalPrinterColumns) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("schema"), schema) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("served"), served) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("storage"), storage) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion, Symbol("subresources"), subresources) - return new(additionalPrinterColumns, name, schema, served, storage, subresources, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion = Dict{Symbol,String}(Symbol("additionalPrinterColumns")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition}", Symbol("name")=>"String", Symbol("schema")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation", Symbol("served")=>"Bool", Symbol("storage")=>"Bool", Symbol("subresources")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion) - o.name === nothing && (return false) - o.served === nothing && (return false) - o.storage === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale.jl deleted file mode 100644 index 4c91e834..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresourceScale -CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale(; - labelSelectorPath=nothing, - specReplicasPath=nothing, - statusReplicasPath=nothing, - ) - - - labelSelectorPath::String : labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. - - specReplicasPath::String : specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET. - - statusReplicasPath::String : statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale <: OpenAPI.APIModel - labelSelectorPath::Union{Nothing, String} = nothing - specReplicasPath::Union{Nothing, String} = nothing - statusReplicasPath::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale(labelSelectorPath, specReplicasPath, statusReplicasPath, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale, Symbol("labelSelectorPath"), labelSelectorPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale, Symbol("specReplicasPath"), specReplicasPath) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale, Symbol("statusReplicasPath"), statusReplicasPath) - return new(labelSelectorPath, specReplicasPath, statusReplicasPath, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale = Dict{Symbol,String}(Symbol("labelSelectorPath")=>"String", Symbol("specReplicasPath")=>"String", Symbol("statusReplicasPath")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale) - o.specReplicasPath === nothing && (return false) - o.statusReplicasPath === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources.jl deleted file mode 100644 index 21adc88e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceSubresources -CustomResourceSubresources defines the status and scale subresources for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources(; - scale=nothing, - status=nothing, - ) - - - scale::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale - - status::Any : CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources <: OpenAPI.APIModel - scale = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale } - status::Union{Nothing, Any} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources(scale, status, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources, Symbol("scale"), scale) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources, Symbol("status"), status) - return new(scale, status, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources = Dict{Symbol,String}(Symbol("scale")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale", Symbol("status")=>"Any", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation.jl deleted file mode 100644 index 5156aedc..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceValidation -CustomResourceValidation is a list of validation methods for CustomResources. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation(; - openAPIV3Schema=nothing, - ) - - - openAPIV3Schema::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation <: OpenAPI.APIModel - openAPIV3Schema = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps } - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation(openAPIV3Schema, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation, Symbol("openAPIV3Schema"), openAPIV3Schema) - return new(openAPIV3Schema, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation = Dict{Symbol,String}(Symbol("openAPIV3Schema")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation.jl deleted file mode 100644 index 0cc0b3f8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.ExternalDocumentation -ExternalDocumentation allows referencing an external resource for extended documentation. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation(; - description=nothing, - url=nothing, - ) - - - description::String - - url::String -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation <: OpenAPI.APIModel - description::Union{Nothing, String} = nothing - url::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation(description, url, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation, Symbol("url"), url) - return new(description, url, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation = Dict{Symbol,String}(Symbol("description")=>"String", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps.jl deleted file mode 100644 index feb9a1ad..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps.jl +++ /dev/null @@ -1,226 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps -JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps(; - var"$ref"=nothing, - var"$schema"=nothing, - additionalItems=nothing, - additionalProperties=nothing, - allOf=nothing, - anyOf=nothing, - default=nothing, - definitions=nothing, - dependencies=nothing, - description=nothing, - enum=nothing, - example=nothing, - exclusiveMaximum=nothing, - exclusiveMinimum=nothing, - externalDocs=nothing, - format=nothing, - id=nothing, - items=nothing, - maxItems=nothing, - maxLength=nothing, - maxProperties=nothing, - maximum=nothing, - minItems=nothing, - minLength=nothing, - minProperties=nothing, - minimum=nothing, - multipleOf=nothing, - not=nothing, - nullable=nothing, - oneOf=nothing, - pattern=nothing, - patternProperties=nothing, - properties=nothing, - required=nothing, - title=nothing, - type=nothing, - uniqueItems=nothing, - var"x-kubernetes-embedded-resource"=nothing, - var"x-kubernetes-int-or-string"=nothing, - var"x-kubernetes-list-map-keys"=nothing, - var"x-kubernetes-list-type"=nothing, - var"x-kubernetes-map-type"=nothing, - var"x-kubernetes-preserve-unknown-fields"=nothing, - ) - - - var"$ref"::String - - var"$schema"::String - - additionalItems::Any : JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property. - - additionalProperties::Any : JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property. - - allOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - anyOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - default::Any : JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. - - definitions::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - dependencies::Dict{String, Any} - - description::String - - enum::Vector{Any} - - example::Any : JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. - - exclusiveMaximum::Bool - - exclusiveMinimum::Bool - - externalDocs::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation - - format::String : format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated: - bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like \"0321751043\" or \"978-0321751041\" - isbn10: an ISBN10 number string like \"0321751043\" - isbn13: an ISBN13 number string like \"978-0321751041\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\d{3}[- ]?\\d{2}[- ]?\\d{4}$ - hexcolor: an hexadecimal color code like \"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like \"rgb(255,255,2559\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \"2006-01-02\" as defined by full-date in RFC3339 - duration: a duration string like \"22 ns\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \"2014-12-15T19:30:20.000Z\" as defined by date-time in RFC3339. - - id::String - - items::Any : JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes. - - maxItems::Int64 - - maxLength::Int64 - - maxProperties::Int64 - - maximum::Float64 - - minItems::Int64 - - minLength::Int64 - - minProperties::Int64 - - minimum::Float64 - - multipleOf::Float64 - - not::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps - - nullable::Bool - - oneOf::Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - pattern::String - - patternProperties::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - properties::Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} - - required::Vector{String} - - title::String - - type::String - - uniqueItems::Bool - - var"x-kubernetes-embedded-resource"::Bool : x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata). - - var"x-kubernetes-int-or-string"::Bool : x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns: 1) anyOf: - type: integer - type: string 2) allOf: - anyOf: - type: integer - type: string - ... zero or more - - var"x-kubernetes-list-map-keys"::Vector{String} : x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map. This tag MUST only be used on lists that have the \"x-kubernetes-list-type\" extension set to \"map\". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported). - - var"x-kubernetes-list-type"::String : x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values: 1) `atomic`: the list is treated as a single entity, like a scalar. Atomic lists will be entirely replaced when updated. This extension may be used on any type of list (struct, scalar, ...). 2) `set`: Sets are lists that must not have multiple items with the same value. Each value must be a scalar, an object with x-kubernetes-map-type `atomic` or an array with x-kubernetes-list-type `atomic`. 3) `map`: These lists are like maps in that their elements have a non-index key used to identify them. Order is preserved upon merge. The map tag must only be used on a list with elements of type object. Defaults to atomic for arrays. - - var"x-kubernetes-map-type"::String : x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values: 1) `granular`: These maps are actual maps (key-value pairs) and each fields are independent from each other (they can each be manipulated by separate actors). This is the default behaviour for all maps. 2) `atomic`: the list is treated as a single entity, like a scalar. Atomic maps will be entirely replaced when updated. - - var"x-kubernetes-preserve-unknown-fields"::Bool : x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps <: OpenAPI.APIModel - var"$ref"::Union{Nothing, String} = nothing - var"$schema"::Union{Nothing, String} = nothing - additionalItems::Union{Nothing, Any} = nothing - additionalProperties::Union{Nothing, Any} = nothing - allOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - anyOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - default::Union{Nothing, Any} = nothing - definitions::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - dependencies::Union{Nothing, Dict{String, Any}} = nothing - description::Union{Nothing, String} = nothing - enum::Union{Nothing, Vector{Any}} = nothing - example::Union{Nothing, Any} = nothing - exclusiveMaximum::Union{Nothing, Bool} = nothing - exclusiveMinimum::Union{Nothing, Bool} = nothing - externalDocs = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation } - format::Union{Nothing, String} = nothing - id::Union{Nothing, String} = nothing - items::Union{Nothing, Any} = nothing - maxItems::Union{Nothing, Int64} = nothing - maxLength::Union{Nothing, Int64} = nothing - maxProperties::Union{Nothing, Int64} = nothing - maximum::Union{Nothing, Float64} = nothing - minItems::Union{Nothing, Int64} = nothing - minLength::Union{Nothing, Int64} = nothing - minProperties::Union{Nothing, Int64} = nothing - minimum::Union{Nothing, Float64} = nothing - multipleOf::Union{Nothing, Float64} = nothing - not = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps } - nullable::Union{Nothing, Bool} = nothing - oneOf::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - pattern::Union{Nothing, String} = nothing - patternProperties::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - properties::Union{Nothing, Dict} = nothing # spec type: Union{ Nothing, Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps} } - required::Union{Nothing, Vector{String}} = nothing - title::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - uniqueItems::Union{Nothing, Bool} = nothing - var"x-kubernetes-embedded-resource"::Union{Nothing, Bool} = nothing - var"x-kubernetes-int-or-string"::Union{Nothing, Bool} = nothing - var"x-kubernetes-list-map-keys"::Union{Nothing, Vector{String}} = nothing - var"x-kubernetes-list-type"::Union{Nothing, String} = nothing - var"x-kubernetes-map-type"::Union{Nothing, String} = nothing - var"x-kubernetes-preserve-unknown-fields"::Union{Nothing, Bool} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps(var"$ref", var"$schema", additionalItems, additionalProperties, allOf, anyOf, default, definitions, dependencies, description, enum, example, exclusiveMaximum, exclusiveMinimum, externalDocs, format, id, items, maxItems, maxLength, maxProperties, maximum, minItems, minLength, minProperties, minimum, multipleOf, not, nullable, oneOf, pattern, patternProperties, properties, required, title, type, uniqueItems, var"x-kubernetes-embedded-resource", var"x-kubernetes-int-or-string", var"x-kubernetes-list-map-keys", var"x-kubernetes-list-type", var"x-kubernetes-map-type", var"x-kubernetes-preserve-unknown-fields", ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("\$ref"), var"$ref") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("\$schema"), var"$schema") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("additionalItems"), additionalItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("additionalProperties"), additionalProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("allOf"), allOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("anyOf"), anyOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("default"), default) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("definitions"), definitions) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("dependencies"), dependencies) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("description"), description) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("enum"), enum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("example"), example) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("exclusiveMaximum"), exclusiveMaximum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("exclusiveMinimum"), exclusiveMinimum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("externalDocs"), externalDocs) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("format"), format) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("id"), id) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("items"), items) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("maxItems"), maxItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("maxLength"), maxLength) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("maxProperties"), maxProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("maximum"), maximum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("minItems"), minItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("minLength"), minLength) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("minProperties"), minProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("minimum"), minimum) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("multipleOf"), multipleOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("not"), not) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("nullable"), nullable) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("oneOf"), oneOf) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("pattern"), pattern) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("patternProperties"), patternProperties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("properties"), properties) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("required"), required) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("title"), title) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("type"), type) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("uniqueItems"), uniqueItems) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-embedded-resource"), var"x-kubernetes-embedded-resource") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-int-or-string"), var"x-kubernetes-int-or-string") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-list-map-keys"), var"x-kubernetes-list-map-keys") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-list-type"), var"x-kubernetes-list-type") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-map-type"), var"x-kubernetes-map-type") - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps, Symbol("x-kubernetes-preserve-unknown-fields"), var"x-kubernetes-preserve-unknown-fields") - return new(var"$ref", var"$schema", additionalItems, additionalProperties, allOf, anyOf, default, definitions, dependencies, description, enum, example, exclusiveMaximum, exclusiveMinimum, externalDocs, format, id, items, maxItems, maxLength, maxProperties, maximum, minItems, minLength, minProperties, minimum, multipleOf, not, nullable, oneOf, pattern, patternProperties, properties, required, title, type, uniqueItems, var"x-kubernetes-embedded-resource", var"x-kubernetes-int-or-string", var"x-kubernetes-list-map-keys", var"x-kubernetes-list-type", var"x-kubernetes-map-type", var"x-kubernetes-preserve-unknown-fields", ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps = Dict{Symbol,String}(Symbol("\$ref")=>"String", Symbol("\$schema")=>"String", Symbol("additionalItems")=>"Any", Symbol("additionalProperties")=>"Any", Symbol("allOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("anyOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("default")=>"Any", Symbol("definitions")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("dependencies")=>"Dict{String, Any}", Symbol("description")=>"String", Symbol("enum")=>"Vector{Any}", Symbol("example")=>"Any", Symbol("exclusiveMaximum")=>"Bool", Symbol("exclusiveMinimum")=>"Bool", Symbol("externalDocs")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation", Symbol("format")=>"String", Symbol("id")=>"String", Symbol("items")=>"Any", Symbol("maxItems")=>"Int64", Symbol("maxLength")=>"Int64", Symbol("maxProperties")=>"Int64", Symbol("maximum")=>"Float64", Symbol("minItems")=>"Int64", Symbol("minLength")=>"Int64", Symbol("minProperties")=>"Int64", Symbol("minimum")=>"Float64", Symbol("multipleOf")=>"Float64", Symbol("not")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", Symbol("nullable")=>"Bool", Symbol("oneOf")=>"Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("pattern")=>"String", Symbol("patternProperties")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("properties")=>"Dict{String, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps}", Symbol("required")=>"Vector{String}", Symbol("title")=>"String", Symbol("type")=>"String", Symbol("uniqueItems")=>"Bool", Symbol("x-kubernetes-embedded-resource")=>"Bool", Symbol("x-kubernetes-int-or-string")=>"Bool", Symbol("x-kubernetes-list-map-keys")=>"Vector{String}", Symbol("x-kubernetes-list-type")=>"String", Symbol("x-kubernetes-map-type")=>"String", Symbol("x-kubernetes-preserve-unknown-fields")=>"Bool", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps }, name::Symbol, val) - if name === Symbol("maxItems") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maxLength") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maxProperties") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("maximum") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "double") - end - if name === Symbol("minItems") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minLength") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minProperties") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "int64") - end - if name === Symbol("minimum") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "double") - end - if name === Symbol("multipleOf") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps", :format, val, "double") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference.jl deleted file mode 100644 index 6ba25990..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference(; - name=nothing, - namespace=nothing, - path=nothing, - port=nothing, - ) - - - name::String : name is the name of the service. Required - - namespace::String : namespace is the namespace of the service. Required - - path::String : path is an optional URL path at which the webhook will be contacted. - - port::Int64 : port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - path::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference(name, namespace, path, port, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference, Symbol("path"), path) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference, Symbol("port"), port) - return new(name, namespace, path, port, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("path")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference) - o.name === nothing && (return false) - o.namespace === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig.jl b/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig.jl deleted file mode 100644 index efb90f86..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.WebhookClientConfig -WebhookClientConfig contains the information to make a TLS connection with the webhook. - - IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig(; - caBundle=nothing, - service=nothing, - url=nothing, - ) - - - caBundle::Vector{UInt8} : caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. - - service::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference - - url::String : url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. -""" -Base.@kwdef mutable struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference } - url::Union{Nothing, String} = nothing - - function IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig(caBundle, service, url, ) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig, Symbol("service"), service) - OpenAPI.validate_property(IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig, Symbol("url"), url) - return new(caBundle, service, url, ) - end -end # type IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig - -const _property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("service")=>"IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference", Symbol("url")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig[name]))} - -function check_required(o::IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroup.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroup.jl deleted file mode 100644 index b6b33394..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroup.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup -APIGroup contains the name, the supported versions, and the preferred version of a group. - - IoK8sApimachineryPkgApisMetaV1APIGroup(; - apiVersion=nothing, - kind=nothing, - name=nothing, - preferredVersion=nothing, - serverAddressByClientCIDRs=nothing, - versions=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : name is the name of the group. - - preferredVersion::IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - - serverAddressByClientCIDRs::Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR} : a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. - - versions::Vector{IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery} : versions are the versions supported in this group. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1APIGroup <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - preferredVersion = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery } - serverAddressByClientCIDRs::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR} } - versions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery} } - - function IoK8sApimachineryPkgApisMetaV1APIGroup(apiVersion, kind, name, preferredVersion, serverAddressByClientCIDRs, versions, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("preferredVersion"), preferredVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("serverAddressByClientCIDRs"), serverAddressByClientCIDRs) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroup, Symbol("versions"), versions) - return new(apiVersion, kind, name, preferredVersion, serverAddressByClientCIDRs, versions, ) - end -end # type IoK8sApimachineryPkgApisMetaV1APIGroup - -const _property_types_IoK8sApimachineryPkgApisMetaV1APIGroup = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("preferredVersion")=>"IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery", Symbol("serverAddressByClientCIDRs")=>"Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR}", Symbol("versions")=>"Vector{IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery}", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1APIGroup }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1APIGroup[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1APIGroup) - o.name === nothing && (return false) - o.versions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1APIGroup }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroupList.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroupList.jl deleted file mode 100644 index 303b8bd8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIGroupList.jl +++ /dev/null @@ -1,40 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.APIGroupList -APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis. - - IoK8sApimachineryPkgApisMetaV1APIGroupList(; - apiVersion=nothing, - groups=nothing, - kind=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - groups::Vector{IoK8sApimachineryPkgApisMetaV1APIGroup} : groups is a list of APIGroup. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1APIGroupList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - groups::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1APIGroup} } - kind::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1APIGroupList(apiVersion, groups, kind, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroupList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroupList, Symbol("groups"), groups) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIGroupList, Symbol("kind"), kind) - return new(apiVersion, groups, kind, ) - end -end # type IoK8sApimachineryPkgApisMetaV1APIGroupList - -const _property_types_IoK8sApimachineryPkgApisMetaV1APIGroupList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("groups")=>"Vector{IoK8sApimachineryPkgApisMetaV1APIGroup}", Symbol("kind")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1APIGroupList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1APIGroupList[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1APIGroupList) - o.groups === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1APIGroupList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResource.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResource.jl deleted file mode 100644 index 03bc55a3..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResource.jl +++ /dev/null @@ -1,72 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.APIResource -APIResource specifies the name of a resource and whether it is namespaced. - - IoK8sApimachineryPkgApisMetaV1APIResource(; - categories=nothing, - group=nothing, - kind=nothing, - name=nothing, - namespaced=nothing, - shortNames=nothing, - singularName=nothing, - storageVersionHash=nothing, - verbs=nothing, - version=nothing, - ) - - - categories::Vector{String} : categories is a list of the grouped resources this resource belongs to (e.g. 'all') - - group::String : group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\". - - kind::String : kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo') - - name::String : name is the plural name of the resource. - - namespaced::Bool : namespaced indicates if a resource is namespaced or not. - - shortNames::Vector{String} : shortNames is a list of suggested short names of the resource. - - singularName::String : singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface. - - storageVersionHash::String : The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates. - - verbs::Vector{String} : verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy) - - version::String : version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\". -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1APIResource <: OpenAPI.APIModel - categories::Union{Nothing, Vector{String}} = nothing - group::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - namespaced::Union{Nothing, Bool} = nothing - shortNames::Union{Nothing, Vector{String}} = nothing - singularName::Union{Nothing, String} = nothing - storageVersionHash::Union{Nothing, String} = nothing - verbs::Union{Nothing, Vector{String}} = nothing - version::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1APIResource(categories, group, kind, name, namespaced, shortNames, singularName, storageVersionHash, verbs, version, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("categories"), categories) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("namespaced"), namespaced) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("shortNames"), shortNames) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("singularName"), singularName) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("storageVersionHash"), storageVersionHash) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("verbs"), verbs) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResource, Symbol("version"), version) - return new(categories, group, kind, name, namespaced, shortNames, singularName, storageVersionHash, verbs, version, ) - end -end # type IoK8sApimachineryPkgApisMetaV1APIResource - -const _property_types_IoK8sApimachineryPkgApisMetaV1APIResource = Dict{Symbol,String}(Symbol("categories")=>"Vector{String}", Symbol("group")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("namespaced")=>"Bool", Symbol("shortNames")=>"Vector{String}", Symbol("singularName")=>"String", Symbol("storageVersionHash")=>"String", Symbol("verbs")=>"Vector{String}", Symbol("version")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1APIResource }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1APIResource[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1APIResource) - o.kind === nothing && (return false) - o.name === nothing && (return false) - o.namespaced === nothing && (return false) - o.singularName === nothing && (return false) - o.verbs === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1APIResource }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResourceList.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResourceList.jl deleted file mode 100644 index 12666363..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIResourceList.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList -APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced. - - IoK8sApimachineryPkgApisMetaV1APIResourceList(; - apiVersion=nothing, - groupVersion=nothing, - kind=nothing, - resources=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - groupVersion::String : groupVersion is the group and version this APIResourceList is for. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - resources::Vector{IoK8sApimachineryPkgApisMetaV1APIResource} : resources contains the name of the resources and if they are namespaced. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1APIResourceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - groupVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - resources::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1APIResource} } - - function IoK8sApimachineryPkgApisMetaV1APIResourceList(apiVersion, groupVersion, kind, resources, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResourceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResourceList, Symbol("groupVersion"), groupVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResourceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIResourceList, Symbol("resources"), resources) - return new(apiVersion, groupVersion, kind, resources, ) - end -end # type IoK8sApimachineryPkgApisMetaV1APIResourceList - -const _property_types_IoK8sApimachineryPkgApisMetaV1APIResourceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("groupVersion")=>"String", Symbol("kind")=>"String", Symbol("resources")=>"Vector{IoK8sApimachineryPkgApisMetaV1APIResource}", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1APIResourceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1APIResourceList[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1APIResourceList) - o.groupVersion === nothing && (return false) - o.resources === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1APIResourceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIVersions.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIVersions.jl deleted file mode 100644 index 60ac82c0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1APIVersions.jl +++ /dev/null @@ -1,45 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions -APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API. - - IoK8sApimachineryPkgApisMetaV1APIVersions(; - apiVersion=nothing, - kind=nothing, - serverAddressByClientCIDRs=nothing, - versions=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - serverAddressByClientCIDRs::Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR} : a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. - - versions::Vector{String} : versions are the api versions that are available. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1APIVersions <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - serverAddressByClientCIDRs::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR} } - versions::Union{Nothing, Vector{String}} = nothing - - function IoK8sApimachineryPkgApisMetaV1APIVersions(apiVersion, kind, serverAddressByClientCIDRs, versions, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIVersions, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIVersions, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIVersions, Symbol("serverAddressByClientCIDRs"), serverAddressByClientCIDRs) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1APIVersions, Symbol("versions"), versions) - return new(apiVersion, kind, serverAddressByClientCIDRs, versions, ) - end -end # type IoK8sApimachineryPkgApisMetaV1APIVersions - -const _property_types_IoK8sApimachineryPkgApisMetaV1APIVersions = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("serverAddressByClientCIDRs")=>"Vector{IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR}", Symbol("versions")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1APIVersions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1APIVersions[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1APIVersions) - o.serverAddressByClientCIDRs === nothing && (return false) - o.versions === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1APIVersions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptions.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptions.jl deleted file mode 100644 index a45777fe..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptions.jl +++ /dev/null @@ -1,58 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions -DeleteOptions may be provided when deleting an API object. - - IoK8sApimachineryPkgApisMetaV1DeleteOptions(; - apiVersion=nothing, - dryRun=nothing, - gracePeriodSeconds=nothing, - kind=nothing, - orphanDependents=nothing, - preconditions=nothing, - propagationPolicy=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - dryRun::Vector{String} : When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed - - gracePeriodSeconds::Int64 : The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - orphanDependents::Bool : Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. - - preconditions::IoK8sApimachineryPkgApisMetaV1Preconditions - - propagationPolicy::String : Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1DeleteOptions <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - dryRun::Union{Nothing, Vector{String}} = nothing - gracePeriodSeconds::Union{Nothing, Int64} = nothing - kind::Union{Nothing, String} = nothing - orphanDependents::Union{Nothing, Bool} = nothing - preconditions = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1Preconditions } - propagationPolicy::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1DeleteOptions(apiVersion, dryRun, gracePeriodSeconds, kind, orphanDependents, preconditions, propagationPolicy, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("dryRun"), dryRun) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("gracePeriodSeconds"), gracePeriodSeconds) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("orphanDependents"), orphanDependents) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("preconditions"), preconditions) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptions, Symbol("propagationPolicy"), propagationPolicy) - return new(apiVersion, dryRun, gracePeriodSeconds, kind, orphanDependents, preconditions, propagationPolicy, ) - end -end # type IoK8sApimachineryPkgApisMetaV1DeleteOptions - -const _property_types_IoK8sApimachineryPkgApisMetaV1DeleteOptions = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("dryRun")=>"Vector{String}", Symbol("gracePeriodSeconds")=>"Int64", Symbol("kind")=>"String", Symbol("orphanDependents")=>"Bool", Symbol("preconditions")=>"IoK8sApimachineryPkgApisMetaV1Preconditions", Symbol("propagationPolicy")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1DeleteOptions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1DeleteOptions[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1DeleteOptions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1DeleteOptions }, name::Symbol, val) - if name === Symbol("gracePeriodSeconds") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1DeleteOptions", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2.jl deleted file mode 100644 index 0093221f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2.jl +++ /dev/null @@ -1,58 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2 -DeleteOptions may be provided when deleting an API object. - - IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2(; - apiVersion=nothing, - dryRun=nothing, - gracePeriodSeconds=nothing, - kind=nothing, - orphanDependents=nothing, - preconditions=nothing, - propagationPolicy=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - dryRun::Vector{String} : When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed - - gracePeriodSeconds::Int64 : The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - orphanDependents::Bool : Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. - - preconditions::IoK8sApimachineryPkgApisMetaV1Preconditions - - propagationPolicy::String : Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - dryRun::Union{Nothing, Vector{String}} = nothing - gracePeriodSeconds::Union{Nothing, Int64} = nothing - kind::Union{Nothing, String} = nothing - orphanDependents::Union{Nothing, Bool} = nothing - preconditions = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1Preconditions } - propagationPolicy::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2(apiVersion, dryRun, gracePeriodSeconds, kind, orphanDependents, preconditions, propagationPolicy, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("dryRun"), dryRun) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("gracePeriodSeconds"), gracePeriodSeconds) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("orphanDependents"), orphanDependents) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("preconditions"), preconditions) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2, Symbol("propagationPolicy"), propagationPolicy) - return new(apiVersion, dryRun, gracePeriodSeconds, kind, orphanDependents, preconditions, propagationPolicy, ) - end -end # type IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 - -const _property_types_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("dryRun")=>"Vector{String}", Symbol("gracePeriodSeconds")=>"Int64", Symbol("kind")=>"String", Symbol("orphanDependents")=>"Bool", Symbol("preconditions")=>"IoK8sApimachineryPkgApisMetaV1Preconditions", Symbol("propagationPolicy")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2 }, name::Symbol, val) - if name === Symbol("gracePeriodSeconds") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1DeleteOptionsV2", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery.jl deleted file mode 100644 index 3395863e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery -GroupVersion contains the \"group/version\" and \"version\" string of a version. It is made a struct to keep extensibility. - - IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery(; - groupVersion=nothing, - version=nothing, - ) - - - groupVersion::String : groupVersion specifies the API group and version in the form \"group/version\" - - version::String : version specifies the version in the form of \"version\". This is to save the clients the trouble of splitting the GroupVersion. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery <: OpenAPI.APIModel - groupVersion::Union{Nothing, String} = nothing - version::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery(groupVersion, version, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery, Symbol("groupVersion"), groupVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery, Symbol("version"), version) - return new(groupVersion, version, ) - end -end # type IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - -const _property_types_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery = Dict{Symbol,String}(Symbol("groupVersion")=>"String", Symbol("version")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery) - o.groupVersion === nothing && (return false) - o.version === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelector.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelector.jl deleted file mode 100644 index 335bf683..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelector.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector -A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. - - IoK8sApimachineryPkgApisMetaV1LabelSelector(; - matchExpressions=nothing, - matchLabels=nothing, - ) - - - matchExpressions::Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement} : matchExpressions is a list of label selector requirements. The requirements are ANDed. - - matchLabels::Dict{String, String} : matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1LabelSelector <: OpenAPI.APIModel - matchExpressions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement} } - matchLabels::Union{Nothing, Dict{String, String}} = nothing - - function IoK8sApimachineryPkgApisMetaV1LabelSelector(matchExpressions, matchLabels, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1LabelSelector, Symbol("matchExpressions"), matchExpressions) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1LabelSelector, Symbol("matchLabels"), matchLabels) - return new(matchExpressions, matchLabels, ) - end -end # type IoK8sApimachineryPkgApisMetaV1LabelSelector - -const _property_types_IoK8sApimachineryPkgApisMetaV1LabelSelector = Dict{Symbol,String}(Symbol("matchExpressions")=>"Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}", Symbol("matchLabels")=>"Dict{String, String}", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1LabelSelector }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1LabelSelector[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1LabelSelector) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1LabelSelector }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement.jl deleted file mode 100644 index acefebc9..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement -A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. - - IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; - key=nothing, - operator=nothing, - values=nothing, - ) - - - key::String : key is the label key that the selector applies to. - - operator::String : operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. - - values::Vector{String} : values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - operator::Union{Nothing, String} = nothing - values::Union{Nothing, Vector{String}} = nothing - - function IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(key, operator, values, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, Symbol("key"), key) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, Symbol("operator"), operator) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, Symbol("values"), values) - return new(key, operator, values, ) - end -end # type IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - -const _property_types_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("operator")=>"String", Symbol("values")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) - o.key === nothing && (return false) - o.operator === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ListMeta.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ListMeta.jl deleted file mode 100644 index b0d130e8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ListMeta.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta -ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. - - IoK8sApimachineryPkgApisMetaV1ListMeta(; - var"continue"=nothing, - remainingItemCount=nothing, - resourceVersion=nothing, - selfLink=nothing, - ) - - - var"continue"::String : continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. - - remainingItemCount::Int64 : remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact. - - resourceVersion::String : String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency - - selfLink::String : selfLink is a URL representing this object. Populated by the system. Read-only. DEPRECATED Kubernetes will stop propagating this field in 1.20 release and the field is planned to be removed in 1.21 release. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1ListMeta <: OpenAPI.APIModel - var"continue"::Union{Nothing, String} = nothing - remainingItemCount::Union{Nothing, Int64} = nothing - resourceVersion::Union{Nothing, String} = nothing - selfLink::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1ListMeta(var"continue", remainingItemCount, resourceVersion, selfLink, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ListMeta, Symbol("continue"), var"continue") - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ListMeta, Symbol("remainingItemCount"), remainingItemCount) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ListMeta, Symbol("resourceVersion"), resourceVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ListMeta, Symbol("selfLink"), selfLink) - return new(var"continue", remainingItemCount, resourceVersion, selfLink, ) - end -end # type IoK8sApimachineryPkgApisMetaV1ListMeta - -const _property_types_IoK8sApimachineryPkgApisMetaV1ListMeta = Dict{Symbol,String}(Symbol("continue")=>"String", Symbol("remainingItemCount")=>"Int64", Symbol("resourceVersion")=>"String", Symbol("selfLink")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1ListMeta }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1ListMeta[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1ListMeta) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1ListMeta }, name::Symbol, val) - if name === Symbol("remainingItemCount") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ListMeta", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry.jl deleted file mode 100644 index 5482027c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry -ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to. - - IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; - apiVersion=nothing, - fieldsType=nothing, - fieldsV1=nothing, - manager=nothing, - operation=nothing, - time=nothing, - ) - - - apiVersion::String : APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted. - - fieldsType::String : FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\" - - fieldsV1::Any : FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format. Each key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:<name>', where <name> is the name of a field in a struct, or key in a map 'v:<value>', where <value> is the exact json formatted value of a list item 'i:<index>', where <index> is position of a item in a list 'k:<keys>', where <keys> is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set. The exact format is defined in sigs.k8s.io/structured-merge-diff - - manager::String : Manager is an identifier of the workflow managing these fields. - - operation::String : Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'. - - time::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - fieldsType::Union{Nothing, String} = nothing - fieldsV1::Union{Nothing, Any} = nothing - manager::Union{Nothing, String} = nothing - operation::Union{Nothing, String} = nothing - time::Union{Nothing, ZonedDateTime} = nothing - - function IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(apiVersion, fieldsType, fieldsV1, manager, operation, time, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("fieldsType"), fieldsType) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("fieldsV1"), fieldsV1) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("manager"), manager) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("operation"), operation) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, Symbol("time"), time) - return new(apiVersion, fieldsType, fieldsV1, manager, operation, time, ) - end -end # type IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - -const _property_types_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("fieldsType")=>"String", Symbol("fieldsV1")=>"Any", Symbol("manager")=>"String", Symbol("operation")=>"String", Symbol("time")=>"ZonedDateTime", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry }, name::Symbol, val) - if name === Symbol("time") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ObjectMeta.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ObjectMeta.jl deleted file mode 100644 index 7911265e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ObjectMeta.jl +++ /dev/null @@ -1,103 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta -ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. - - IoK8sApimachineryPkgApisMetaV1ObjectMeta(; - annotations=nothing, - clusterName=nothing, - creationTimestamp=nothing, - deletionGracePeriodSeconds=nothing, - deletionTimestamp=nothing, - finalizers=nothing, - generateName=nothing, - generation=nothing, - labels=nothing, - managedFields=nothing, - name=nothing, - namespace=nothing, - ownerReferences=nothing, - resourceVersion=nothing, - selfLink=nothing, - uid=nothing, - ) - - - annotations::Dict{String, String} : Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations - - clusterName::String : The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. - - creationTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - deletionGracePeriodSeconds::Int64 : Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. - - deletionTimestamp::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - finalizers::Vector{String} : Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list. - - generateName::String : GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency - - generation::Int64 : A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. - - labels::Dict{String, String} : Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels - - managedFields::Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry} : ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object. - - name::String : Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names - - namespace::String : Namespace defines the space within each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces - - ownerReferences::Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference} : List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. - - resourceVersion::String : An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency - - selfLink::String : SelfLink is a URL representing this object. Populated by the system. Read-only. DEPRECATED Kubernetes will stop propagating this field in 1.20 release and the field is planned to be removed in 1.21 release. - - uid::String : UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1ObjectMeta <: OpenAPI.APIModel - annotations::Union{Nothing, Dict{String, String}} = nothing - clusterName::Union{Nothing, String} = nothing - creationTimestamp::Union{Nothing, ZonedDateTime} = nothing - deletionGracePeriodSeconds::Union{Nothing, Int64} = nothing - deletionTimestamp::Union{Nothing, ZonedDateTime} = nothing - finalizers::Union{Nothing, Vector{String}} = nothing - generateName::Union{Nothing, String} = nothing - generation::Union{Nothing, Int64} = nothing - labels::Union{Nothing, Dict{String, String}} = nothing - managedFields::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry} } - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - ownerReferences::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference} } - resourceVersion::Union{Nothing, String} = nothing - selfLink::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1ObjectMeta(annotations, clusterName, creationTimestamp, deletionGracePeriodSeconds, deletionTimestamp, finalizers, generateName, generation, labels, managedFields, name, namespace, ownerReferences, resourceVersion, selfLink, uid, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("annotations"), annotations) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("clusterName"), clusterName) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("creationTimestamp"), creationTimestamp) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("deletionGracePeriodSeconds"), deletionGracePeriodSeconds) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("deletionTimestamp"), deletionTimestamp) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("finalizers"), finalizers) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("generateName"), generateName) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("generation"), generation) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("labels"), labels) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("managedFields"), managedFields) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("ownerReferences"), ownerReferences) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("resourceVersion"), resourceVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("selfLink"), selfLink) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ObjectMeta, Symbol("uid"), uid) - return new(annotations, clusterName, creationTimestamp, deletionGracePeriodSeconds, deletionTimestamp, finalizers, generateName, generation, labels, managedFields, name, namespace, ownerReferences, resourceVersion, selfLink, uid, ) - end -end # type IoK8sApimachineryPkgApisMetaV1ObjectMeta - -const _property_types_IoK8sApimachineryPkgApisMetaV1ObjectMeta = Dict{Symbol,String}(Symbol("annotations")=>"Dict{String, String}", Symbol("clusterName")=>"String", Symbol("creationTimestamp")=>"ZonedDateTime", Symbol("deletionGracePeriodSeconds")=>"Int64", Symbol("deletionTimestamp")=>"ZonedDateTime", Symbol("finalizers")=>"Vector{String}", Symbol("generateName")=>"String", Symbol("generation")=>"Int64", Symbol("labels")=>"Dict{String, String}", Symbol("managedFields")=>"Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}", Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("ownerReferences")=>"Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}", Symbol("resourceVersion")=>"String", Symbol("selfLink")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1ObjectMeta }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1ObjectMeta[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1ObjectMeta) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1ObjectMeta }, name::Symbol, val) - if name === Symbol("creationTimestamp") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ObjectMeta", :format, val, "date-time") - end - if name === Symbol("deletionGracePeriodSeconds") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ObjectMeta", :format, val, "int64") - end - if name === Symbol("deletionTimestamp") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ObjectMeta", :format, val, "date-time") - end - if name === Symbol("generation") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1ObjectMeta", :format, val, "int64") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1OwnerReference.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1OwnerReference.jl deleted file mode 100644 index a4ad8414..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1OwnerReference.jl +++ /dev/null @@ -1,55 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference -OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. - - IoK8sApimachineryPkgApisMetaV1OwnerReference(; - apiVersion=nothing, - blockOwnerDeletion=nothing, - controller=nothing, - kind=nothing, - name=nothing, - uid=nothing, - ) - - - apiVersion::String : API version of the referent. - - blockOwnerDeletion::Bool : If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. - - controller::Bool : If true, this reference points to the managing controller. - - kind::String : Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names - - uid::String : UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1OwnerReference <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - blockOwnerDeletion::Union{Nothing, Bool} = nothing - controller::Union{Nothing, Bool} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1OwnerReference(apiVersion, blockOwnerDeletion, controller, kind, name, uid, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("blockOwnerDeletion"), blockOwnerDeletion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("controller"), controller) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1OwnerReference, Symbol("uid"), uid) - return new(apiVersion, blockOwnerDeletion, controller, kind, name, uid, ) - end -end # type IoK8sApimachineryPkgApisMetaV1OwnerReference - -const _property_types_IoK8sApimachineryPkgApisMetaV1OwnerReference = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("blockOwnerDeletion")=>"Bool", Symbol("controller")=>"Bool", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1OwnerReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1OwnerReference[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1OwnerReference) - o.apiVersion === nothing && (return false) - o.kind === nothing && (return false) - o.name === nothing && (return false) - o.uid === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1OwnerReference }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Preconditions.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Preconditions.jl deleted file mode 100644 index ca2747ee..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Preconditions.jl +++ /dev/null @@ -1,35 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions -Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. - - IoK8sApimachineryPkgApisMetaV1Preconditions(; - resourceVersion=nothing, - uid=nothing, - ) - - - resourceVersion::String : Specifies the target ResourceVersion - - uid::String : Specifies the target UID. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1Preconditions <: OpenAPI.APIModel - resourceVersion::Union{Nothing, String} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1Preconditions(resourceVersion, uid, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Preconditions, Symbol("resourceVersion"), resourceVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Preconditions, Symbol("uid"), uid) - return new(resourceVersion, uid, ) - end -end # type IoK8sApimachineryPkgApisMetaV1Preconditions - -const _property_types_IoK8sApimachineryPkgApisMetaV1Preconditions = Dict{Symbol,String}(Symbol("resourceVersion")=>"String", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1Preconditions }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1Preconditions[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1Preconditions) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1Preconditions }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR.jl deleted file mode 100644 index 6c4e26d5..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR -ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. - - IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR(; - clientCIDR=nothing, - serverAddress=nothing, - ) - - - clientCIDR::String : The CIDR with which clients can match their IP to figure out the server address that they should use. - - serverAddress::String : Address of this server, suitable for a client that matches the above CIDR. This can be a hostname, hostname:port, IP or IP:port. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR <: OpenAPI.APIModel - clientCIDR::Union{Nothing, String} = nothing - serverAddress::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR(clientCIDR, serverAddress, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR, Symbol("clientCIDR"), clientCIDR) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR, Symbol("serverAddress"), serverAddress) - return new(clientCIDR, serverAddress, ) - end -end # type IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - -const _property_types_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR = Dict{Symbol,String}(Symbol("clientCIDR")=>"String", Symbol("serverAddress")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR) - o.clientCIDR === nothing && (return false) - o.serverAddress === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Status.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Status.jl deleted file mode 100644 index a8d8e5c8..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1Status.jl +++ /dev/null @@ -1,62 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.Status -Status is a return value for calls that don't return other objects. - - IoK8sApimachineryPkgApisMetaV1Status(; - apiVersion=nothing, - code=nothing, - details=nothing, - kind=nothing, - message=nothing, - metadata=nothing, - reason=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - code::Int64 : Suggested HTTP return code for this status, 0 if not set. - - details::IoK8sApimachineryPkgApisMetaV1StatusDetails - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - message::String : A human-readable description of the status of this operation. - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta - - reason::String : A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. - - status::String : Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1Status <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - code::Union{Nothing, Int64} = nothing - details = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1StatusDetails } - kind::Union{Nothing, String} = nothing - message::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1Status(apiVersion, code, details, kind, message, metadata, reason, status, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("code"), code) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("details"), details) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1Status, Symbol("status"), status) - return new(apiVersion, code, details, kind, message, metadata, reason, status, ) - end -end # type IoK8sApimachineryPkgApisMetaV1Status - -const _property_types_IoK8sApimachineryPkgApisMetaV1Status = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("code")=>"Int64", Symbol("details")=>"IoK8sApimachineryPkgApisMetaV1StatusDetails", Symbol("kind")=>"String", Symbol("message")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", Symbol("reason")=>"String", Symbol("status")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1Status }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1Status[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1Status) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1Status }, name::Symbol, val) - if name === Symbol("code") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1Status", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusCause.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusCause.jl deleted file mode 100644 index 483e892f..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusCause.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause -StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. - - IoK8sApimachineryPkgApisMetaV1StatusCause(; - field=nothing, - message=nothing, - reason=nothing, - ) - - - field::String : The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. Examples: \"name\" - the field \"name\" on the current resource \"items[0].name\" - the field \"name\" on the first array entry in \"items\" - - message::String : A human-readable description of the cause of the error. This field may be presented as-is to a reader. - - reason::String : A machine-readable description of the cause of the error. If this value is empty there is no information available. -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1StatusCause <: OpenAPI.APIModel - field::Union{Nothing, String} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1StatusCause(field, message, reason, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusCause, Symbol("field"), field) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusCause, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusCause, Symbol("reason"), reason) - return new(field, message, reason, ) - end -end # type IoK8sApimachineryPkgApisMetaV1StatusCause - -const _property_types_IoK8sApimachineryPkgApisMetaV1StatusCause = Dict{Symbol,String}(Symbol("field")=>"String", Symbol("message")=>"String", Symbol("reason")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1StatusCause }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1StatusCause[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1StatusCause) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1StatusCause }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetails.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetails.jl deleted file mode 100644 index 06681f4c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetails.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails -StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. - - IoK8sApimachineryPkgApisMetaV1StatusDetails(; - causes=nothing, - group=nothing, - kind=nothing, - name=nothing, - retryAfterSeconds=nothing, - uid=nothing, - ) - - - causes::Vector{IoK8sApimachineryPkgApisMetaV1StatusCause} : The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. - - group::String : The group attribute of the resource associated with the status StatusReason. - - kind::String : The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). - - retryAfterSeconds::Int64 : If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. - - uid::String : UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1StatusDetails <: OpenAPI.APIModel - causes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1StatusCause} } - group::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - retryAfterSeconds::Union{Nothing, Int64} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1StatusDetails(causes, group, kind, name, retryAfterSeconds, uid, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("causes"), causes) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("retryAfterSeconds"), retryAfterSeconds) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetails, Symbol("uid"), uid) - return new(causes, group, kind, name, retryAfterSeconds, uid, ) - end -end # type IoK8sApimachineryPkgApisMetaV1StatusDetails - -const _property_types_IoK8sApimachineryPkgApisMetaV1StatusDetails = Dict{Symbol,String}(Symbol("causes")=>"Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}", Symbol("group")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("retryAfterSeconds")=>"Int64", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1StatusDetails }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1StatusDetails[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1StatusDetails) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1StatusDetails }, name::Symbol, val) - if name === Symbol("retryAfterSeconds") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1StatusDetails", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2.jl deleted file mode 100644 index 3e249516..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2.jl +++ /dev/null @@ -1,54 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails_v2 -StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. - - IoK8sApimachineryPkgApisMetaV1StatusDetailsV2(; - causes=nothing, - group=nothing, - kind=nothing, - name=nothing, - retryAfterSeconds=nothing, - uid=nothing, - ) - - - causes::Vector{IoK8sApimachineryPkgApisMetaV1StatusCause} : The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. - - group::String : The group attribute of the resource associated with the status StatusReason. - - kind::String : The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - name::String : The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). - - retryAfterSeconds::Int64 : If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. - - uid::String : UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 <: OpenAPI.APIModel - causes::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sApimachineryPkgApisMetaV1StatusCause} } - group::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - retryAfterSeconds::Union{Nothing, Int64} = nothing - uid::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1StatusDetailsV2(causes, group, kind, name, retryAfterSeconds, uid, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("causes"), causes) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("group"), group) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("name"), name) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("retryAfterSeconds"), retryAfterSeconds) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusDetailsV2, Symbol("uid"), uid) - return new(causes, group, kind, name, retryAfterSeconds, uid, ) - end -end # type IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 - -const _property_types_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 = Dict{Symbol,String}(Symbol("causes")=>"Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}", Symbol("group")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", Symbol("retryAfterSeconds")=>"Int64", Symbol("uid")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1StatusDetailsV2[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1StatusDetailsV2) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 }, name::Symbol, val) - if name === Symbol("retryAfterSeconds") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1StatusDetailsV2", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusV2.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusV2.jl deleted file mode 100644 index bd7f7ac0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1StatusV2.jl +++ /dev/null @@ -1,62 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 -Status is a return value for calls that don't return other objects. - - IoK8sApimachineryPkgApisMetaV1StatusV2(; - apiVersion=nothing, - code=nothing, - details=nothing, - kind=nothing, - message=nothing, - metadata=nothing, - reason=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - code::Int64 : Suggested HTTP return code for this status, 0 if not set. - - details::IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - message::String : A human-readable description of the status of this operation. - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta - - reason::String : A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. - - status::String : Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1StatusV2 <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - code::Union{Nothing, Int64} = nothing - details = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 } - kind::Union{Nothing, String} = nothing - message::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1StatusV2(apiVersion, code, details, kind, message, metadata, reason, status, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("code"), code) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("details"), details) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("message"), message) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1StatusV2, Symbol("status"), status) - return new(apiVersion, code, details, kind, message, metadata, reason, status, ) - end -end # type IoK8sApimachineryPkgApisMetaV1StatusV2 - -const _property_types_IoK8sApimachineryPkgApisMetaV1StatusV2 = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("code")=>"Int64", Symbol("details")=>"IoK8sApimachineryPkgApisMetaV1StatusDetailsV2", Symbol("kind")=>"String", Symbol("message")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", Symbol("reason")=>"String", Symbol("status")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1StatusV2 }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1StatusV2[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1StatusV2) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1StatusV2 }, name::Symbol, val) - if name === Symbol("code") - OpenAPI.validate_param(name, "IoK8sApimachineryPkgApisMetaV1StatusV2", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1WatchEvent.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1WatchEvent.jl deleted file mode 100644 index c887eeec..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgApisMetaV1WatchEvent.jl +++ /dev/null @@ -1,37 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent -Event represents a single event to a watched resource. - - IoK8sApimachineryPkgApisMetaV1WatchEvent(; - object=nothing, - type=nothing, - ) - - - object::Any : RawExtension is used to hold extensions in external versions. To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. // Internal package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.Object `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // External package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.RawExtension `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // On the wire, the JSON will look something like this: { \"kind\":\"MyAPIObject\", \"apiVersion\":\"v1\", \"myPlugin\": { \"kind\":\"PluginA\", \"aOption\":\"foo\", }, } So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) - - type::String -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgApisMetaV1WatchEvent <: OpenAPI.APIModel - object::Union{Nothing, Any} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgApisMetaV1WatchEvent(object, type, ) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1WatchEvent, Symbol("object"), object) - OpenAPI.validate_property(IoK8sApimachineryPkgApisMetaV1WatchEvent, Symbol("type"), type) - return new(object, type, ) - end -end # type IoK8sApimachineryPkgApisMetaV1WatchEvent - -const _property_types_IoK8sApimachineryPkgApisMetaV1WatchEvent = Dict{Symbol,String}(Symbol("object")=>"Any", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgApisMetaV1WatchEvent }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgApisMetaV1WatchEvent[name]))} - -function check_required(o::IoK8sApimachineryPkgApisMetaV1WatchEvent) - o.object === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgApisMetaV1WatchEvent }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgVersionInfo.jl b/src/ApiImpl/api/models/model_IoK8sApimachineryPkgVersionInfo.jl deleted file mode 100644 index 6380b26a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sApimachineryPkgVersionInfo.jl +++ /dev/null @@ -1,72 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.apimachinery.pkg.version.Info -Info contains versioning information. how we'll want to distribute that information. - - IoK8sApimachineryPkgVersionInfo(; - buildDate=nothing, - compiler=nothing, - gitCommit=nothing, - gitTreeState=nothing, - gitVersion=nothing, - goVersion=nothing, - major=nothing, - minor=nothing, - platform=nothing, - ) - - - buildDate::String - - compiler::String - - gitCommit::String - - gitTreeState::String - - gitVersion::String - - goVersion::String - - major::String - - minor::String - - platform::String -""" -Base.@kwdef mutable struct IoK8sApimachineryPkgVersionInfo <: OpenAPI.APIModel - buildDate::Union{Nothing, String} = nothing - compiler::Union{Nothing, String} = nothing - gitCommit::Union{Nothing, String} = nothing - gitTreeState::Union{Nothing, String} = nothing - gitVersion::Union{Nothing, String} = nothing - goVersion::Union{Nothing, String} = nothing - major::Union{Nothing, String} = nothing - minor::Union{Nothing, String} = nothing - platform::Union{Nothing, String} = nothing - - function IoK8sApimachineryPkgVersionInfo(buildDate, compiler, gitCommit, gitTreeState, gitVersion, goVersion, major, minor, platform, ) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("buildDate"), buildDate) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("compiler"), compiler) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("gitCommit"), gitCommit) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("gitTreeState"), gitTreeState) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("gitVersion"), gitVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("goVersion"), goVersion) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("major"), major) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("minor"), minor) - OpenAPI.validate_property(IoK8sApimachineryPkgVersionInfo, Symbol("platform"), platform) - return new(buildDate, compiler, gitCommit, gitTreeState, gitVersion, goVersion, major, minor, platform, ) - end -end # type IoK8sApimachineryPkgVersionInfo - -const _property_types_IoK8sApimachineryPkgVersionInfo = Dict{Symbol,String}(Symbol("buildDate")=>"String", Symbol("compiler")=>"String", Symbol("gitCommit")=>"String", Symbol("gitTreeState")=>"String", Symbol("gitVersion")=>"String", Symbol("goVersion")=>"String", Symbol("major")=>"String", Symbol("minor")=>"String", Symbol("platform")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sApimachineryPkgVersionInfo }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApimachineryPkgVersionInfo[name]))} - -function check_required(o::IoK8sApimachineryPkgVersionInfo) - o.buildDate === nothing && (return false) - o.compiler === nothing && (return false) - o.gitCommit === nothing && (return false) - o.gitTreeState === nothing && (return false) - o.gitVersion === nothing && (return false) - o.goVersion === nothing && (return false) - o.major === nothing && (return false) - o.minor === nothing && (return false) - o.platform === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sApimachineryPkgVersionInfo }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService.jl deleted file mode 100644 index a07ff43a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService -APIService represents a server for a particular GroupVersion. Name must be \"version.group\". - - IoK8sKubeAggregatorPkgApisApiregistrationV1APIService(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec - - status::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIService <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec } - status = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1APIService(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1APIService - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec", Symbol("status")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIService }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIService[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIService }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition.jl deleted file mode 100644 index 6e0afc82..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition -APIServiceCondition describes the state of an APIService at a particular point - - IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human-readable message indicating details about last transition. - - reason::String : Unique, one-word, CamelCase reason for the condition's last transition. - - status::String : Status is the status of the condition. Can be True, False, Unknown. - - type::String : Type is the type of the condition. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList.jl deleted file mode 100644 index 3c294823..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList -APIServiceList is a list of APIService objects. - - IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec.jl deleted file mode 100644 index 4c72652e..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec -APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. - - IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec(; - caBundle=nothing, - group=nothing, - groupPriorityMinimum=nothing, - insecureSkipTLSVerify=nothing, - service=nothing, - version=nothing, - versionPriority=nothing, - ) - - - caBundle::Vector{UInt8} : CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. - - group::String : Group is the API group name this server hosts - - groupPriorityMinimum::Int64 : GroupPriorityMininum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMininum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s - - insecureSkipTLSVerify::Bool : InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead. - - service::IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference - - version::String : Version is the API version this server hosts. For example, \"v1\" - - versionPriority::Int64 : VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - group::Union{Nothing, String} = nothing - groupPriorityMinimum::Union{Nothing, Int64} = nothing - insecureSkipTLSVerify::Union{Nothing, Bool} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference } - version::Union{Nothing, String} = nothing - versionPriority::Union{Nothing, Int64} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec(caBundle, group, groupPriorityMinimum, insecureSkipTLSVerify, service, version, versionPriority, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("group"), group) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("groupPriorityMinimum"), groupPriorityMinimum) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("insecureSkipTLSVerify"), insecureSkipTLSVerify) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("service"), service) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("version"), version) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, Symbol("versionPriority"), versionPriority) - return new(caBundle, group, groupPriorityMinimum, insecureSkipTLSVerify, service, version, versionPriority, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("group")=>"String", Symbol("groupPriorityMinimum")=>"Int64", Symbol("insecureSkipTLSVerify")=>"Bool", Symbol("service")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference", Symbol("version")=>"String", Symbol("versionPriority")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec) - o.groupPriorityMinimum === nothing && (return false) - o.service === nothing && (return false) - o.versionPriority === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end - if name === Symbol("groupPriorityMinimum") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec", :format, val, "int32") - end - if name === Symbol("versionPriority") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus.jl deleted file mode 100644 index e1b23d9a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus -APIServiceStatus contains derived information about an API server - - IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus(; - conditions=nothing, - ) - - - conditions::Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition} : Current service state of apiService. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition} } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus(conditions, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus, Symbol("conditions"), conditions) - return new(conditions, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition}", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference.jl deleted file mode 100644 index 1c39216a..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference(; - name=nothing, - namespace=nothing, - port=nothing, - ) - - - name::String : Name is the name of the service - - namespace::String : Namespace is the namespace of the service - - port::Int64 : If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference(name, namespace, port, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference, Symbol("port"), port) - return new(name, namespace, port, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService.jl deleted file mode 100644 index c4dc50c0..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.APIService -APIService represents a server for a particular GroupVersion. Name must be \"version.group\". - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec - - status::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec } - status = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, Symbol("metadata"), metadata) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, Symbol("spec"), spec) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec", Symbol("status")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition.jl deleted file mode 100644 index 3dea20f6..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition.jl +++ /dev/null @@ -1,52 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.APIServiceCondition -APIServiceCondition describes the state of an APIService at a particular point - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::ZonedDateTime : Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. - - message::String : Human-readable message indicating details about last transition. - - reason::String : Unique, one-word, CamelCase reason for the condition's last transition. - - status::String : Status is the status of the condition. Can be True, False, Unknown. - - type::String : Type is the type of the condition. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, ZonedDateTime} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition(lastTransitionTime, message, reason, status, type, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition, Symbol("message"), message) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition, Symbol("reason"), reason) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition, Symbol("status"), status) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition, Symbol("type"), type) - return new(lastTransitionTime, message, reason, status, type, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"ZonedDateTime", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition }, name::Symbol, val) - if name === Symbol("lastTransitionTime") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList.jl deleted file mode 100644 index 954a3326..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.APIServiceList -APIServiceList is a list of APIService objects. - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService} - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, Symbol("items"), items) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, Symbol("kind"), kind) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec.jl deleted file mode 100644 index a8ec3a34..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec.jl +++ /dev/null @@ -1,70 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.APIServiceSpec -APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec(; - caBundle=nothing, - group=nothing, - groupPriorityMinimum=nothing, - insecureSkipTLSVerify=nothing, - service=nothing, - version=nothing, - versionPriority=nothing, - ) - - - caBundle::Vector{UInt8} : CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. - - group::String : Group is the API group name this server hosts - - groupPriorityMinimum::Int64 : GroupPriorityMininum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMininum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s - - insecureSkipTLSVerify::Bool : InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead. - - service::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference - - version::String : Version is the API version this server hosts. For example, \"v1\" - - versionPriority::Int64 : VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec <: OpenAPI.APIModel - caBundle::Union{Nothing, Vector{UInt8}} = nothing - group::Union{Nothing, String} = nothing - groupPriorityMinimum::Union{Nothing, Int64} = nothing - insecureSkipTLSVerify::Union{Nothing, Bool} = nothing - service = nothing # spec type: Union{ Nothing, IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference } - version::Union{Nothing, String} = nothing - versionPriority::Union{Nothing, Int64} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec(caBundle, group, groupPriorityMinimum, insecureSkipTLSVerify, service, version, versionPriority, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("caBundle"), caBundle) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("group"), group) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("groupPriorityMinimum"), groupPriorityMinimum) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("insecureSkipTLSVerify"), insecureSkipTLSVerify) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("service"), service) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("version"), version) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec, Symbol("versionPriority"), versionPriority) - return new(caBundle, group, groupPriorityMinimum, insecureSkipTLSVerify, service, version, versionPriority, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec = Dict{Symbol,String}(Symbol("caBundle")=>"Vector{UInt8}", Symbol("group")=>"String", Symbol("groupPriorityMinimum")=>"Int64", Symbol("insecureSkipTLSVerify")=>"Bool", Symbol("service")=>"IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference", Symbol("version")=>"String", Symbol("versionPriority")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec) - o.groupPriorityMinimum === nothing && (return false) - o.service === nothing && (return false) - o.versionPriority === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec }, name::Symbol, val) - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec", :format, val, "byte") - end - if name === Symbol("caBundle") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec", :pattern, val, r"^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$") - end - if name === Symbol("groupPriorityMinimum") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec", :format, val, "int32") - end - if name === Symbol("versionPriority") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus.jl deleted file mode 100644 index 257b444c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.APIServiceStatus -APIServiceStatus contains derived information about an API server - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus(; - conditions=nothing, - ) - - - conditions::Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition} : Current service state of apiService. -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition} } - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus(conditions, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus, Symbol("conditions"), conditions) - return new(conditions, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition}", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference.jl b/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference.jl deleted file mode 100644 index af42736c..00000000 --- a/src/ApiImpl/api/models/model_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""io.k8s.kube-aggregator.pkg.apis.apiregistration.v1beta1.ServiceReference -ServiceReference holds a reference to Service.legacy.k8s.io - - IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference(; - name=nothing, - namespace=nothing, - port=nothing, - ) - - - name::String : Name is the name of the service - - namespace::String : Namespace is the namespace of the service - - port::Int64 : If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). -""" -Base.@kwdef mutable struct IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference <: OpenAPI.APIModel - name::Union{Nothing, String} = nothing - namespace::Union{Nothing, String} = nothing - port::Union{Nothing, Int64} = nothing - - function IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference(name, namespace, port, ) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference, Symbol("name"), name) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference, Symbol("namespace"), namespace) - OpenAPI.validate_property(IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference, Symbol("port"), port) - return new(name, namespace, port, ) - end -end # type IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference - -const _property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference = Dict{Symbol,String}(Symbol("name")=>"String", Symbol("namespace")=>"String", Symbol("port")=>"Int64", ) -OpenAPI.property_type(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference[name]))} - -function check_required(o::IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference) - true -end - -function OpenAPI.validate_property(::Type{ IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference }, name::Symbol, val) - if name === Symbol("port") - OpenAPI.validate_param(name, "IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5Provisioner.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5Provisioner.jl deleted file mode 100644 index 269b7688..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5Provisioner.jl +++ /dev/null @@ -1,47 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh.karpenter.v1alpha5.Provisioner -Provisioner is the Schema for the Provisioners API - - ShKarpenterV1alpha5Provisioner(; - apiVersion=nothing, - kind=nothing, - metadata=nothing, - spec=nothing, - status=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta - - spec::ShKarpenterV1alpha5ProvisionerSpec - - status::ShKarpenterV1alpha5ProvisionerStatus -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5Provisioner <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ObjectMeta } - spec = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerSpec } - status = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerStatus } - - function ShKarpenterV1alpha5Provisioner(apiVersion, kind, metadata, spec, status, ) - OpenAPI.validate_property(ShKarpenterV1alpha5Provisioner, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(ShKarpenterV1alpha5Provisioner, Symbol("kind"), kind) - OpenAPI.validate_property(ShKarpenterV1alpha5Provisioner, Symbol("metadata"), metadata) - OpenAPI.validate_property(ShKarpenterV1alpha5Provisioner, Symbol("spec"), spec) - OpenAPI.validate_property(ShKarpenterV1alpha5Provisioner, Symbol("status"), status) - return new(apiVersion, kind, metadata, spec, status, ) - end -end # type ShKarpenterV1alpha5Provisioner - -const _property_types_ShKarpenterV1alpha5Provisioner = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ObjectMeta", Symbol("spec")=>"ShKarpenterV1alpha5ProvisionerSpec", Symbol("status")=>"ShKarpenterV1alpha5ProvisionerStatus", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5Provisioner }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5Provisioner[name]))} - -function check_required(o::ShKarpenterV1alpha5Provisioner) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5Provisioner }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerList.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerList.jl deleted file mode 100644 index 2016ad3f..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerList.jl +++ /dev/null @@ -1,44 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh.karpenter.v1alpha5.ProvisionerList -ProvisionerList is a list of Provisioner - - ShKarpenterV1alpha5ProvisionerList(; - apiVersion=nothing, - items=nothing, - kind=nothing, - metadata=nothing, - ) - - - apiVersion::String : APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources - - items::Vector{ShKarpenterV1alpha5Provisioner} : List of provisioners. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md - - kind::String : Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds - - metadata::IoK8sApimachineryPkgApisMetaV1ListMeta -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerList <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - items::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ShKarpenterV1alpha5Provisioner} } - kind::Union{Nothing, String} = nothing - metadata = nothing # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1ListMeta } - - function ShKarpenterV1alpha5ProvisionerList(apiVersion, items, kind, metadata, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerList, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerList, Symbol("items"), items) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerList, Symbol("kind"), kind) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerList, Symbol("metadata"), metadata) - return new(apiVersion, items, kind, metadata, ) - end -end # type ShKarpenterV1alpha5ProvisionerList - -const _property_types_ShKarpenterV1alpha5ProvisionerList = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("items")=>"Vector{ShKarpenterV1alpha5Provisioner}", Symbol("kind")=>"String", Symbol("metadata")=>"IoK8sApimachineryPkgApisMetaV1ListMeta", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerList }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerList[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerList) - o.items === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerList }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpec.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpec.jl deleted file mode 100644 index c1dc7686..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpec.jl +++ /dev/null @@ -1,88 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec -ProvisionerSpec is the top level provisioner specification. Provisioners launch nodes in response to pods that are unschedulable. A single provisioner is capable of managing a diverse set of nodes. Node properties are determined from a combination of provisioner and pod scheduling constraints. - - ShKarpenterV1alpha5ProvisionerSpec(; - consolidation=nothing, - kubeletConfiguration=nothing, - labels=nothing, - limits=nothing, - provider=nothing, - providerRef=nothing, - requirements=nothing, - startupTaints=nothing, - taints=nothing, - ttlSecondsAfterEmpty=nothing, - ttlSecondsUntilExpired=nothing, - weight=nothing, - ) - - - consolidation::ShKarpenterV1alpha5ProvisionerSpecConsolidation - - kubeletConfiguration::ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration - - labels::Dict{String, String} : Labels are layered with Requirements and applied to every node. - - limits::ShKarpenterV1alpha5ProvisionerSpecLimits - - provider::Any : Provider contains fields specific to your cloudprovider. - - providerRef::ShKarpenterV1alpha5ProvisionerSpecProviderRef - - requirements::Vector{ShKarpenterV1alpha5ProvisionerSpecRequirementsInner} : Requirements are layered with Labels and applied to every node. - - startupTaints::Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner} : StartupTaints are taints that are applied to nodes upon startup which are expected to be removed automatically within a short period of time, typically by a DaemonSet that tolerates the taint. These are commonly used by daemonsets to allow initialization and enforce startup ordering. StartupTaints are ignored for provisioning purposes in that pods are not required to tolerate a StartupTaint in order to have nodes provisioned for them. - - taints::Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner} : Taints will be applied to every node launched by the Provisioner. If specified, the provisioner will not provision nodes for pods that do not have matching tolerations. Additional taints will be created that match pod tolerations on a per-node basis. - - ttlSecondsAfterEmpty::Int64 : TTLSecondsAfterEmpty is the number of seconds the controller will wait before attempting to delete a node, measured from when the node is detected to be empty. A Node is considered to be empty when it does not have pods scheduled to it, excluding daemonsets. Termination due to no utilization is disabled if this field is not set. - - ttlSecondsUntilExpired::Int64 : TTLSecondsUntilExpired is the number of seconds the controller will wait before terminating a node, measured from when the node is created. This is useful to implement features like eventually consistent node upgrade, memory leak protection, and disruption testing. Termination due to expiration is disabled if this field is not set. - - weight::Int64 : Weight is the priority given to the provisioner during scheduling. A higher numerical weight indicates that this provisioner will be ordered ahead of other provisioners with lower weights. A provisioner with no weight will be treated as if it is a provisioner with a weight of 0. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpec <: OpenAPI.APIModel - consolidation = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerSpecConsolidation } - kubeletConfiguration = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration } - labels::Union{Nothing, Dict{String, String}} = nothing - limits = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerSpecLimits } - provider::Union{Nothing, Any} = nothing - providerRef = nothing # spec type: Union{ Nothing, ShKarpenterV1alpha5ProvisionerSpecProviderRef } - requirements::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ShKarpenterV1alpha5ProvisionerSpecRequirementsInner} } - startupTaints::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner} } - taints::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner} } - ttlSecondsAfterEmpty::Union{Nothing, Int64} = nothing - ttlSecondsUntilExpired::Union{Nothing, Int64} = nothing - weight::Union{Nothing, Int64} = nothing - - function ShKarpenterV1alpha5ProvisionerSpec(consolidation, kubeletConfiguration, labels, limits, provider, providerRef, requirements, startupTaints, taints, ttlSecondsAfterEmpty, ttlSecondsUntilExpired, weight, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("consolidation"), consolidation) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("kubeletConfiguration"), kubeletConfiguration) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("labels"), labels) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("limits"), limits) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("provider"), provider) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("providerRef"), providerRef) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("requirements"), requirements) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("startupTaints"), startupTaints) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("taints"), taints) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("ttlSecondsAfterEmpty"), ttlSecondsAfterEmpty) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("ttlSecondsUntilExpired"), ttlSecondsUntilExpired) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpec, Symbol("weight"), weight) - return new(consolidation, kubeletConfiguration, labels, limits, provider, providerRef, requirements, startupTaints, taints, ttlSecondsAfterEmpty, ttlSecondsUntilExpired, weight, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpec - -const _property_types_ShKarpenterV1alpha5ProvisionerSpec = Dict{Symbol,String}(Symbol("consolidation")=>"ShKarpenterV1alpha5ProvisionerSpecConsolidation", Symbol("kubeletConfiguration")=>"ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration", Symbol("labels")=>"Dict{String, String}", Symbol("limits")=>"ShKarpenterV1alpha5ProvisionerSpecLimits", Symbol("provider")=>"Any", Symbol("providerRef")=>"ShKarpenterV1alpha5ProvisionerSpecProviderRef", Symbol("requirements")=>"Vector{ShKarpenterV1alpha5ProvisionerSpecRequirementsInner}", Symbol("startupTaints")=>"Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner}", Symbol("taints")=>"Vector{ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner}", Symbol("ttlSecondsAfterEmpty")=>"Int64", Symbol("ttlSecondsUntilExpired")=>"Int64", Symbol("weight")=>"Int64", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpec[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpec) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpec }, name::Symbol, val) - if name === Symbol("ttlSecondsAfterEmpty") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpec", :format, val, "int64") - end - if name === Symbol("ttlSecondsUntilExpired") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpec", :format, val, "int64") - end - if name === Symbol("weight") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpec", :format, val, "int32") - end - if name === Symbol("weight") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpec", :maximum, val, 100, false) - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpec", :minimum, val, 1, false) - end -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecConsolidation.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecConsolidation.jl deleted file mode 100644 index c1c98181..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecConsolidation.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_consolidation -Consolidation are the consolidation parameters - - ShKarpenterV1alpha5ProvisionerSpecConsolidation(; - enabled=nothing, - ) - - - enabled::Bool : Enabled enables consolidation if it has been set -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecConsolidation <: OpenAPI.APIModel - enabled::Union{Nothing, Bool} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecConsolidation(enabled, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecConsolidation, Symbol("enabled"), enabled) - return new(enabled, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecConsolidation - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecConsolidation = Dict{Symbol,String}(Symbol("enabled")=>"Bool", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecConsolidation }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecConsolidation[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecConsolidation) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecConsolidation }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration.jl deleted file mode 100644 index 8f37f9d0..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration.jl +++ /dev/null @@ -1,46 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_kubeletConfiguration -KubeletConfiguration are options passed to the kubelet when provisioning nodes - - ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration(; - clusterDNS=nothing, - containerRuntime=nothing, - maxPods=nothing, - systemReserved=nothing, - ) - - - clusterDNS::Vector{String} : clusterDNS is a list of IP addresses for the cluster DNS server. Note that not all providers may use all addresses. - - containerRuntime::String : ContainerRuntime is the container runtime to be used with your worker nodes. - - maxPods::Int64 : MaxPods is an override for the maximum number of pods that can run on a worker node instance. - - systemReserved::Dict{String, Any} : SystemReserved contains resources reserved for OS system daemons and kernel memory. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration <: OpenAPI.APIModel - clusterDNS::Union{Nothing, Vector{String}} = nothing - containerRuntime::Union{Nothing, String} = nothing - maxPods::Union{Nothing, Int64} = nothing - systemReserved::Union{Nothing, Dict{String, Any}} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration(clusterDNS, containerRuntime, maxPods, systemReserved, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration, Symbol("clusterDNS"), clusterDNS) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration, Symbol("containerRuntime"), containerRuntime) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration, Symbol("maxPods"), maxPods) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration, Symbol("systemReserved"), systemReserved) - return new(clusterDNS, containerRuntime, maxPods, systemReserved, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration = Dict{Symbol,String}(Symbol("clusterDNS")=>"Vector{String}", Symbol("containerRuntime")=>"String", Symbol("maxPods")=>"Int64", Symbol("systemReserved")=>"Dict{String, Any}", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration }, name::Symbol, val) - if name === Symbol("maxPods") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration", :format, val, "int32") - end -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecLimits.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecLimits.jl deleted file mode 100644 index 12dd8df8..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecLimits.jl +++ /dev/null @@ -1,31 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_limits -Limits define a set of bounds for provisioning capacity. - - ShKarpenterV1alpha5ProvisionerSpecLimits(; - resources=nothing, - ) - - - resources::Dict{String, Any} : Resources contains all the allocatable resources that Karpenter supports for limiting. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecLimits <: OpenAPI.APIModel - resources::Union{Nothing, Dict{String, Any}} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecLimits(resources, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecLimits, Symbol("resources"), resources) - return new(resources, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecLimits - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecLimits = Dict{Symbol,String}(Symbol("resources")=>"Dict{String, Any}", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecLimits }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecLimits[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecLimits) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecLimits }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecProviderRef.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecProviderRef.jl deleted file mode 100644 index 47259617..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecProviderRef.jl +++ /dev/null @@ -1,39 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_providerRef -ProviderRef is a reference to a dedicated CRD for the chosen provider, that holds additional configuration options - - ShKarpenterV1alpha5ProvisionerSpecProviderRef(; - apiVersion=nothing, - kind=nothing, - name=nothing, - ) - - - apiVersion::String : API version of the referent - - kind::String : Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\" - - name::String : Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecProviderRef <: OpenAPI.APIModel - apiVersion::Union{Nothing, String} = nothing - kind::Union{Nothing, String} = nothing - name::Union{Nothing, String} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecProviderRef(apiVersion, kind, name, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecProviderRef, Symbol("apiVersion"), apiVersion) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecProviderRef, Symbol("kind"), kind) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecProviderRef, Symbol("name"), name) - return new(apiVersion, kind, name, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecProviderRef - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecProviderRef = Dict{Symbol,String}(Symbol("apiVersion")=>"String", Symbol("kind")=>"String", Symbol("name")=>"String", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecProviderRef }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecProviderRef[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecProviderRef) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecProviderRef }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner.jl deleted file mode 100644 index 5f358e7b..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner.jl +++ /dev/null @@ -1,41 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_requirements_inner -A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. - - ShKarpenterV1alpha5ProvisionerSpecRequirementsInner(; - key=nothing, - operator=nothing, - values=nothing, - ) - - - key::String : The label key that the selector applies to. - - operator::String : Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. - - values::Vector{String} : An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecRequirementsInner <: OpenAPI.APIModel - key::Union{Nothing, String} = nothing - operator::Union{Nothing, String} = nothing - values::Union{Nothing, Vector{String}} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecRequirementsInner(key, operator, values, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecRequirementsInner, Symbol("key"), key) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecRequirementsInner, Symbol("operator"), operator) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecRequirementsInner, Symbol("values"), values) - return new(key, operator, values, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecRequirementsInner - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner = Dict{Symbol,String}(Symbol("key")=>"String", Symbol("operator")=>"String", Symbol("values")=>"Vector{String}", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecRequirementsInner }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecRequirementsInner[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecRequirementsInner) - o.key === nothing && (return false) - o.operator === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecRequirementsInner }, name::Symbol, val) -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner.jl deleted file mode 100644 index 5e3f027c..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner.jl +++ /dev/null @@ -1,48 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_spec_startupTaints_inner -The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint. - - ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner(; - effect=nothing, - key=nothing, - timeAdded=nothing, - value=nothing, - ) - - - effect::String : Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. - - key::String : Required. The taint key to be applied to a node. - - timeAdded::ZonedDateTime : TimeAdded represents the time at which the taint was added. It is only written for NoExecute taints. - - value::String : The taint value corresponding to the taint key. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner <: OpenAPI.APIModel - effect::Union{Nothing, String} = nothing - key::Union{Nothing, String} = nothing - timeAdded::Union{Nothing, ZonedDateTime} = nothing - value::Union{Nothing, String} = nothing - - function ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner(effect, key, timeAdded, value, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner, Symbol("effect"), effect) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner, Symbol("key"), key) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner, Symbol("timeAdded"), timeAdded) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner, Symbol("value"), value) - return new(effect, key, timeAdded, value, ) - end -end # type ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner - -const _property_types_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner = Dict{Symbol,String}(Symbol("effect")=>"String", Symbol("key")=>"String", Symbol("timeAdded")=>"ZonedDateTime", Symbol("value")=>"String", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner) - o.effect === nothing && (return false) - o.key === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner }, name::Symbol, val) - if name === Symbol("timeAdded") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatus.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatus.jl deleted file mode 100644 index b469b44a..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatus.jl +++ /dev/null @@ -1,42 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_status -ProvisionerStatus defines the observed state of Provisioner - - ShKarpenterV1alpha5ProvisionerStatus(; - conditions=nothing, - lastScaleTime=nothing, - resources=nothing, - ) - - - conditions::Vector{ShKarpenterV1alpha5ProvisionerStatusConditionsInner} : Conditions is the set of conditions required for this provisioner to scale its target, and indicates whether or not those conditions are met. - - lastScaleTime::ZonedDateTime : LastScaleTime is the last time the Provisioner scaled the number of nodes - - resources::Dict{String, Any} : Resources is the list of resources that have been provisioned. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerStatus <: OpenAPI.APIModel - conditions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ShKarpenterV1alpha5ProvisionerStatusConditionsInner} } - lastScaleTime::Union{Nothing, ZonedDateTime} = nothing - resources::Union{Nothing, Dict{String, Any}} = nothing - - function ShKarpenterV1alpha5ProvisionerStatus(conditions, lastScaleTime, resources, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatus, Symbol("conditions"), conditions) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatus, Symbol("lastScaleTime"), lastScaleTime) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatus, Symbol("resources"), resources) - return new(conditions, lastScaleTime, resources, ) - end -end # type ShKarpenterV1alpha5ProvisionerStatus - -const _property_types_ShKarpenterV1alpha5ProvisionerStatus = Dict{Symbol,String}(Symbol("conditions")=>"Vector{ShKarpenterV1alpha5ProvisionerStatusConditionsInner}", Symbol("lastScaleTime")=>"ZonedDateTime", Symbol("resources")=>"Dict{String, Any}", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerStatus }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerStatus[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerStatus) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerStatus }, name::Symbol, val) - if name === Symbol("lastScaleTime") - OpenAPI.validate_param(name, "ShKarpenterV1alpha5ProvisionerStatus", :format, val, "date-time") - end -end diff --git a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatusConditionsInner.jl b/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatusConditionsInner.jl deleted file mode 100644 index 349b9884..00000000 --- a/src/ApiImpl/api/models/model_ShKarpenterV1alpha5ProvisionerStatusConditionsInner.jl +++ /dev/null @@ -1,53 +0,0 @@ -# This file was generated by the Julia OpenAPI Code Generator -# Do not modify this file directly. Modify the OpenAPI specification instead. - - -@doc raw"""sh_karpenter_v1alpha5_Provisioner_status_conditions_inner -Condition defines a readiness condition for a Knative resource. See: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties - - ShKarpenterV1alpha5ProvisionerStatusConditionsInner(; - lastTransitionTime=nothing, - message=nothing, - reason=nothing, - severity=nothing, - status=nothing, - type=nothing, - ) - - - lastTransitionTime::String : LastTransitionTime is the last time the condition transitioned from one status to another. We use VolatileTime in place of metav1.Time to exclude this from creating equality.Semantic differences (all other things held constant). - - message::String : A human readable message indicating details about the transition. - - reason::String : The reason for the condition's last transition. - - severity::String : Severity with which to treat failures of this type of condition. When this is not specified, it defaults to Error. - - status::String : Status of the condition, one of True, False, Unknown. - - type::String : Type of condition. -""" -Base.@kwdef mutable struct ShKarpenterV1alpha5ProvisionerStatusConditionsInner <: OpenAPI.APIModel - lastTransitionTime::Union{Nothing, String} = nothing - message::Union{Nothing, String} = nothing - reason::Union{Nothing, String} = nothing - severity::Union{Nothing, String} = nothing - status::Union{Nothing, String} = nothing - type::Union{Nothing, String} = nothing - - function ShKarpenterV1alpha5ProvisionerStatusConditionsInner(lastTransitionTime, message, reason, severity, status, type, ) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("lastTransitionTime"), lastTransitionTime) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("message"), message) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("reason"), reason) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("severity"), severity) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("status"), status) - OpenAPI.validate_property(ShKarpenterV1alpha5ProvisionerStatusConditionsInner, Symbol("type"), type) - return new(lastTransitionTime, message, reason, severity, status, type, ) - end -end # type ShKarpenterV1alpha5ProvisionerStatusConditionsInner - -const _property_types_ShKarpenterV1alpha5ProvisionerStatusConditionsInner = Dict{Symbol,String}(Symbol("lastTransitionTime")=>"String", Symbol("message")=>"String", Symbol("reason")=>"String", Symbol("severity")=>"String", Symbol("status")=>"String", Symbol("type")=>"String", ) -OpenAPI.property_type(::Type{ ShKarpenterV1alpha5ProvisionerStatusConditionsInner }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ShKarpenterV1alpha5ProvisionerStatusConditionsInner[name]))} - -function check_required(o::ShKarpenterV1alpha5ProvisionerStatusConditionsInner) - o.status === nothing && (return false) - o.type === nothing && (return false) - true -end - -function OpenAPI.validate_property(::Type{ ShKarpenterV1alpha5ProvisionerStatusConditionsInner }, name::Symbol, val) -end diff --git a/src/ApiImpl/api_typemap.jl b/src/ApiImpl/api_typemap.jl deleted file mode 100644 index 5605d38c..00000000 --- a/src/ApiImpl/api_typemap.jl +++ /dev/null @@ -1,2216 +0,0 @@ -module Typedefs - using ..Kubernetes - module BatchV1beta1 - using ..Kubernetes - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const JobSpec = Kubernetes.IoK8sApiBatchV1JobSpec - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const CronJobList = Kubernetes.IoK8sApiBatchV1beta1CronJobList - const JobTemplateSpec = Kubernetes.IoK8sApiBatchV1beta1JobTemplateSpec - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const CronJob = Kubernetes.IoK8sApiBatchV1beta1CronJob - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const CronJobStatus = Kubernetes.IoK8sApiBatchV1beta1CronJobStatus - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const CronJobSpec = Kubernetes.IoK8sApiBatchV1beta1CronJobSpec - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end - module EventsV1beta1 - using ..Kubernetes - const EventSeries = Kubernetes.IoK8sApiEventsV1beta1EventSeries - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const EventSource = Kubernetes.IoK8sApiCoreV1EventSource - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const Event = Kubernetes.IoK8sApiEventsV1beta1Event - const EventList = Kubernetes.IoK8sApiEventsV1beta1EventList - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module CertificatesV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const CertificateSigningRequestList = Kubernetes.IoK8sApiCertificatesV1beta1CertificateSigningRequestList - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const CertificateSigningRequestCondition = Kubernetes.IoK8sApiCertificatesV1beta1CertificateSigningRequestCondition - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const CertificateSigningRequest = Kubernetes.IoK8sApiCertificatesV1beta1CertificateSigningRequest - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const CertificateSigningRequestSpec = Kubernetes.IoK8sApiCertificatesV1beta1CertificateSigningRequestSpec - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const CertificateSigningRequestStatus = Kubernetes.IoK8sApiCertificatesV1beta1CertificateSigningRequestStatus - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module BatchV1 - using ..Kubernetes - const CronJob = Kubernetes.IoK8sApiBatchV1CronJob - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Job = Kubernetes.IoK8sApiBatchV1Job - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const JobList = Kubernetes.IoK8sApiBatchV1JobList - const JobCondition = Kubernetes.IoK8sApiBatchV1JobCondition - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const JobSpec = Kubernetes.IoK8sApiBatchV1JobSpec - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const CronJobStatus = Kubernetes.IoK8sApiBatchV1CronJobStatus - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const JobStatus = Kubernetes.IoK8sApiBatchV1JobStatus - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const CronJobList = Kubernetes.IoK8sApiBatchV1CronJobList - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const CronJobSpec = Kubernetes.IoK8sApiBatchV1CronJobSpec - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const JobTemplateSpec = Kubernetes.IoK8sApiBatchV1JobTemplateSpec - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end - module SchedulingV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const PriorityClassList = Kubernetes.IoK8sApiSchedulingV1alpha1PriorityClassList - const PriorityClass = Kubernetes.IoK8sApiSchedulingV1alpha1PriorityClass - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AppsV1beta2 - using ..Kubernetes - const StatefulSet = Kubernetes.IoK8sApiAppsV1beta2StatefulSet - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const ReplicaSetStatus = Kubernetes.IoK8sApiAppsV1beta2ReplicaSetStatus - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const ControllerRevisionList = Kubernetes.IoK8sApiAppsV1beta2ControllerRevisionList - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const DaemonSet = Kubernetes.IoK8sApiAppsV1beta2DaemonSet - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const StatefulSetList = Kubernetes.IoK8sApiAppsV1beta2StatefulSetList - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const DaemonSetSpec = Kubernetes.IoK8sApiAppsV1beta2DaemonSetSpec - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const DeploymentStrategy = Kubernetes.IoK8sApiAppsV1beta2DeploymentStrategy - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const PersistentVolumeClaimStatus = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimStatus - const StatefulSetSpec = Kubernetes.IoK8sApiAppsV1beta2StatefulSetSpec - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const DeploymentStatus = Kubernetes.IoK8sApiAppsV1beta2DeploymentStatus - const ScaleSpec = Kubernetes.IoK8sApiAppsV1beta2ScaleSpec - const DaemonSetStatus = Kubernetes.IoK8sApiAppsV1beta2DaemonSetStatus - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Scale = Kubernetes.IoK8sApiAppsV1beta2Scale - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const StatefulSetCondition = Kubernetes.IoK8sApiAppsV1beta2StatefulSetCondition - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const DeploymentList = Kubernetes.IoK8sApiAppsV1beta2DeploymentList - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const DeploymentCondition = Kubernetes.IoK8sApiAppsV1beta2DeploymentCondition - const StatefulSetStatus = Kubernetes.IoK8sApiAppsV1beta2StatefulSetStatus - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const DaemonSetUpdateStrategy = Kubernetes.IoK8sApiAppsV1beta2DaemonSetUpdateStrategy - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TypedLocalObjectReference = Kubernetes.IoK8sApiCoreV1TypedLocalObjectReference - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const PersistentVolumeClaimSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimSpec - const PersistentVolumeClaimCondition = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimCondition - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const ScaleStatus = Kubernetes.IoK8sApiAppsV1beta2ScaleStatus - const RollingUpdateDaemonSet = Kubernetes.IoK8sApiAppsV1beta2RollingUpdateDaemonSet - const ReplicaSetCondition = Kubernetes.IoK8sApiAppsV1beta2ReplicaSetCondition - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const ReplicaSet = Kubernetes.IoK8sApiAppsV1beta2ReplicaSet - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const Deployment = Kubernetes.IoK8sApiAppsV1beta2Deployment - const DaemonSetList = Kubernetes.IoK8sApiAppsV1beta2DaemonSetList - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatefulSetUpdateStrategy = Kubernetes.IoK8sApiAppsV1beta2StatefulSetUpdateStrategy - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const ReplicaSetSpec = Kubernetes.IoK8sApiAppsV1beta2ReplicaSetSpec - const RollingUpdateStatefulSetStrategy = Kubernetes.IoK8sApiAppsV1beta2RollingUpdateStatefulSetStrategy - const DeploymentSpec = Kubernetes.IoK8sApiAppsV1beta2DeploymentSpec - const PersistentVolumeClaim = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaim - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const RollingUpdateDeployment = Kubernetes.IoK8sApiAppsV1beta2RollingUpdateDeployment - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const DaemonSetCondition = Kubernetes.IoK8sApiAppsV1beta2DaemonSetCondition - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const ControllerRevision = Kubernetes.IoK8sApiAppsV1beta2ControllerRevision - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ReplicaSetList = Kubernetes.IoK8sApiAppsV1beta2ReplicaSetList - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end - module PolicyV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const SupplementalGroupsStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1SupplementalGroupsStrategyOptions - const AllowedHostPath = Kubernetes.IoK8sApiPolicyV1beta1AllowedHostPath - const PodDisruptionBudgetList = Kubernetes.IoK8sApiPolicyV1beta1PodDisruptionBudgetList - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const AllowedCSIDriver = Kubernetes.IoK8sApiPolicyV1beta1AllowedCSIDriver - const PodDisruptionBudgetSpec = Kubernetes.IoK8sApiPolicyV1beta1PodDisruptionBudgetSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const PodSecurityPolicySpec = Kubernetes.IoK8sApiPolicyV1beta1PodSecurityPolicySpec - const IDRange = Kubernetes.IoK8sApiPolicyV1beta1IDRange - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const HostPortRange = Kubernetes.IoK8sApiPolicyV1beta1HostPortRange - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const PodDisruptionBudgetStatus = Kubernetes.IoK8sApiPolicyV1beta1PodDisruptionBudgetStatus - const PodDisruptionBudget = Kubernetes.IoK8sApiPolicyV1beta1PodDisruptionBudget - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const RuntimeClassStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1RuntimeClassStrategyOptions - const RunAsGroupStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1RunAsGroupStrategyOptions - const PodSecurityPolicy = Kubernetes.IoK8sApiPolicyV1beta1PodSecurityPolicy - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const AllowedFlexVolume = Kubernetes.IoK8sApiPolicyV1beta1AllowedFlexVolume - const SELinuxStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1SELinuxStrategyOptions - const RunAsUserStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1RunAsUserStrategyOptions - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const FSGroupStrategyOptions = Kubernetes.IoK8sApiPolicyV1beta1FSGroupStrategyOptions - const PodSecurityPolicyList = Kubernetes.IoK8sApiPolicyV1beta1PodSecurityPolicyList - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module RbacAuthorizationV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const ClusterRoleBinding = Kubernetes.IoK8sApiRbacV1beta1ClusterRoleBinding - const PolicyRule = Kubernetes.IoK8sApiRbacV1beta1PolicyRule - const RoleList = Kubernetes.IoK8sApiRbacV1beta1RoleList - const AggregationRule = Kubernetes.IoK8sApiRbacV1beta1AggregationRule - const RoleBinding = Kubernetes.IoK8sApiRbacV1beta1RoleBinding - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const Subject = Kubernetes.IoK8sApiRbacV1beta1Subject - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ClusterRole = Kubernetes.IoK8sApiRbacV1beta1ClusterRole - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const RoleBindingList = Kubernetes.IoK8sApiRbacV1beta1RoleBindingList - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const ClusterRoleList = Kubernetes.IoK8sApiRbacV1beta1ClusterRoleList - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const RoleRef = Kubernetes.IoK8sApiRbacV1beta1RoleRef - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const ClusterRoleBindingList = Kubernetes.IoK8sApiRbacV1beta1ClusterRoleBindingList - const Role = Kubernetes.IoK8sApiRbacV1beta1Role - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AuthorizationV1beta1 - using ..Kubernetes - const SubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1beta1SubjectAccessReview - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const SelfSubjectRulesReviewSpec = Kubernetes.IoK8sApiAuthorizationV1beta1SelfSubjectRulesReviewSpec - const SubjectAccessReviewSpec = Kubernetes.IoK8sApiAuthorizationV1beta1SubjectAccessReviewSpec - const SelfSubjectAccessReviewSpec = Kubernetes.IoK8sApiAuthorizationV1beta1SelfSubjectAccessReviewSpec - const ResourceAttributes = Kubernetes.IoK8sApiAuthorizationV1beta1ResourceAttributes - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const SubjectRulesReviewStatus = Kubernetes.IoK8sApiAuthorizationV1beta1SubjectRulesReviewStatus - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const LocalSubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1beta1LocalSubjectAccessReview - const SelfSubjectRulesReview = Kubernetes.IoK8sApiAuthorizationV1beta1SelfSubjectRulesReview - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ResourceRule = Kubernetes.IoK8sApiAuthorizationV1beta1ResourceRule - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const NonResourceAttributes = Kubernetes.IoK8sApiAuthorizationV1beta1NonResourceAttributes - const SelfSubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1beta1SelfSubjectAccessReview - const SubjectAccessReviewStatus = Kubernetes.IoK8sApiAuthorizationV1beta1SubjectAccessReviewStatus - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const NonResourceRule = Kubernetes.IoK8sApiAuthorizationV1beta1NonResourceRule - end - module SettingsV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const PodPreset = Kubernetes.IoK8sApiSettingsV1alpha1PodPreset - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const PodPresetSpec = Kubernetes.IoK8sApiSettingsV1alpha1PodPresetSpec - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const PodPresetList = Kubernetes.IoK8sApiSettingsV1alpha1PodPresetList - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - end - module Apis - using ..Kubernetes - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - end - module ApiregistrationV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIServiceCondition = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const APIServiceSpec = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec - const ServiceReference = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const APIService = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1APIService - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const APIServiceStatus = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const APIServiceList = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList - end - module MetricsV1beta1 - using ..Kubernetes - const ContainerMetrics = Kubernetes.IoK8sApiMetricsV1beta1ContainerMetrics - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const NodeMetricsList = Kubernetes.IoK8sApiMetricsV1beta1NodeMetricsList - const NodeMetrics = Kubernetes.IoK8sApiMetricsV1beta1NodeMetrics - const PodMetrics = Kubernetes.IoK8sApiMetricsV1beta1PodMetrics - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodMetricsList = Kubernetes.IoK8sApiMetricsV1beta1PodMetricsList - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module RbacAuthorizationV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ClusterRoleBinding = Kubernetes.IoK8sApiRbacV1ClusterRoleBinding - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const RoleList = Kubernetes.IoK8sApiRbacV1RoleList - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const PolicyRule = Kubernetes.IoK8sApiRbacV1PolicyRule - const RoleBinding = Kubernetes.IoK8sApiRbacV1RoleBinding - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const RoleBindingList = Kubernetes.IoK8sApiRbacV1RoleBindingList - const Subject = Kubernetes.IoK8sApiRbacV1Subject - const ClusterRole = Kubernetes.IoK8sApiRbacV1ClusterRole - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const RoleRef = Kubernetes.IoK8sApiRbacV1RoleRef - const ClusterRoleList = Kubernetes.IoK8sApiRbacV1ClusterRoleList - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const Role = Kubernetes.IoK8sApiRbacV1Role - const AggregationRule = Kubernetes.IoK8sApiRbacV1AggregationRule - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const ClusterRoleBindingList = Kubernetes.IoK8sApiRbacV1ClusterRoleBindingList - end - module AutoscalingV2beta2 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const PodsMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta2PodsMetricStatus - const MetricValueStatus = Kubernetes.IoK8sApiAutoscalingV2beta2MetricValueStatus - const ObjectMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta2ObjectMetricStatus - const HorizontalPodAutoscaler = Kubernetes.IoK8sApiAutoscalingV2beta2HorizontalPodAutoscaler - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const MetricSpec = Kubernetes.IoK8sApiAutoscalingV2beta2MetricSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const HorizontalPodAutoscalerCondition = Kubernetes.IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerCondition - const ExternalMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta2ExternalMetricSource - const ResourceMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta2ResourceMetricStatus - const MetricTarget = Kubernetes.IoK8sApiAutoscalingV2beta2MetricTarget - const ResourceMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta2ResourceMetricSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const HorizontalPodAutoscalerSpec = Kubernetes.IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerSpec - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const ExternalMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta2ExternalMetricStatus - const MetricIdentifier = Kubernetes.IoK8sApiAutoscalingV2beta2MetricIdentifier - const HorizontalPodAutoscalerList = Kubernetes.IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerList - const HorizontalPodAutoscalerStatus = Kubernetes.IoK8sApiAutoscalingV2beta2HorizontalPodAutoscalerStatus - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const ObjectMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta2ObjectMetricSource - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const MetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta2MetricStatus - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const CrossVersionObjectReference = Kubernetes.IoK8sApiAutoscalingV2beta2CrossVersionObjectReference - const PodsMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta2PodsMetricSource - end - module AuthenticationV1beta1 - using ..Kubernetes - const UserInfo = Kubernetes.IoK8sApiAuthenticationV1beta1UserInfo - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const TokenReview = Kubernetes.IoK8sApiAuthenticationV1beta1TokenReview - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const TokenReviewStatus = Kubernetes.IoK8sApiAuthenticationV1beta1TokenReviewStatus - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const TokenReviewSpec = Kubernetes.IoK8sApiAuthenticationV1beta1TokenReviewSpec - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AuthorizationV1 - using ..Kubernetes - const SelfSubjectRulesReview = Kubernetes.IoK8sApiAuthorizationV1SelfSubjectRulesReview - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const LocalSubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1LocalSubjectAccessReview - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const SubjectAccessReviewSpec = Kubernetes.IoK8sApiAuthorizationV1SubjectAccessReviewSpec - const ResourceAttributes = Kubernetes.IoK8sApiAuthorizationV1ResourceAttributes - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const NonResourceRule = Kubernetes.IoK8sApiAuthorizationV1NonResourceRule - const SubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1SubjectAccessReview - const SelfSubjectAccessReviewSpec = Kubernetes.IoK8sApiAuthorizationV1SelfSubjectAccessReviewSpec - const SubjectAccessReviewStatus = Kubernetes.IoK8sApiAuthorizationV1SubjectAccessReviewStatus - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const SubjectRulesReviewStatus = Kubernetes.IoK8sApiAuthorizationV1SubjectRulesReviewStatus - const SelfSubjectRulesReviewSpec = Kubernetes.IoK8sApiAuthorizationV1SelfSubjectRulesReviewSpec - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NonResourceAttributes = Kubernetes.IoK8sApiAuthorizationV1NonResourceAttributes - const ResourceRule = Kubernetes.IoK8sApiAuthorizationV1ResourceRule - const SelfSubjectAccessReview = Kubernetes.IoK8sApiAuthorizationV1SelfSubjectAccessReview - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module ApiextensionsV1beta1 - using ..Kubernetes - const CustomResourceDefinitionCondition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionCondition - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const CustomResourceColumnDefinition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceColumnDefinition - const JSONSchemaProps = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1JSONSchemaProps - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const CustomResourceDefinitionNames = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionNames - const ServiceReference = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ServiceReference - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const CustomResourceDefinition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinition - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const CustomResourceDefinitionList = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionList - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const CustomResourceConversion = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceConversion - const WebhookClientConfig = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1WebhookClientConfig - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const CustomResourceDefinitionSpec = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionSpec - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const ExternalDocumentation = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1ExternalDocumentation - const CustomResourceSubresourceScale = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresourceScale - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const CustomResourceDefinitionStatus = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionStatus - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const CustomResourceValidation = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceValidation - const CustomResourceSubresources = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceSubresources - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const CustomResourceDefinitionVersion = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1beta1CustomResourceDefinitionVersion - end - module CoordinationV1beta1 - using ..Kubernetes - const LeaseList = Kubernetes.IoK8sApiCoordinationV1beta1LeaseList - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const Lease = Kubernetes.IoK8sApiCoordinationV1beta1Lease - const LeaseSpec = Kubernetes.IoK8sApiCoordinationV1beta1LeaseSpec - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module CoordinationV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const Lease = Kubernetes.IoK8sApiCoordinationV1Lease - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const LeaseSpec = Kubernetes.IoK8sApiCoordinationV1LeaseSpec - const LeaseList = Kubernetes.IoK8sApiCoordinationV1LeaseList - end - module NodeV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const Overhead = Kubernetes.IoK8sApiNodeV1alpha1Overhead - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const RuntimeClass = Kubernetes.IoK8sApiNodeV1alpha1RuntimeClass - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const RuntimeClassSpec = Kubernetes.IoK8sApiNodeV1alpha1RuntimeClassSpec - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RuntimeClassList = Kubernetes.IoK8sApiNodeV1alpha1RuntimeClassList - const Scheduling = Kubernetes.IoK8sApiNodeV1alpha1Scheduling - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module StorageV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const CSINodeList = Kubernetes.IoK8sApiStorageV1beta1CSINodeList - const CinderPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CinderPersistentVolumeSource - const CSIDriver = Kubernetes.IoK8sApiStorageV1beta1CSIDriver - const ScaleIOPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOPersistentVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const StorageClassList = Kubernetes.IoK8sApiStorageV1beta1StorageClassList - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const StorageOSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSPersistentVolumeSource - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const VolumeAttachmentList = Kubernetes.IoK8sApiStorageV1beta1VolumeAttachmentList - const CSINode = Kubernetes.IoK8sApiStorageV1beta1CSINode - const VolumeError = Kubernetes.IoK8sApiStorageV1beta1VolumeError - const VolumeAttachmentSpec = Kubernetes.IoK8sApiStorageV1beta1VolumeAttachmentSpec - const VolumeAttachmentStatus = Kubernetes.IoK8sApiStorageV1beta1VolumeAttachmentStatus - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const TopologySelectorLabelRequirement = Kubernetes.IoK8sApiCoreV1TopologySelectorLabelRequirement - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const TopologySelectorTerm = Kubernetes.IoK8sApiCoreV1TopologySelectorTerm - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LocalVolumeSource = Kubernetes.IoK8sApiCoreV1LocalVolumeSource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const CSIDriverList = Kubernetes.IoK8sApiStorageV1beta1CSIDriverList - const VolumeNodeResources = Kubernetes.IoK8sApiStorageV1beta1VolumeNodeResources - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const ISCSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIPersistentVolumeSource - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const CephFSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSPersistentVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const PersistentVolumeSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const CSIDriverSpec = Kubernetes.IoK8sApiStorageV1beta1CSIDriverSpec - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const GlusterfsPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsPersistentVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RBDPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1RBDPersistentVolumeSource - const VolumeNodeAffinity = Kubernetes.IoK8sApiCoreV1VolumeNodeAffinity - const VolumeAttachmentSource = Kubernetes.IoK8sApiStorageV1beta1VolumeAttachmentSource - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const FlexPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1FlexPersistentVolumeSource - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const VolumeAttachment = Kubernetes.IoK8sApiStorageV1beta1VolumeAttachment - const CSINodeSpec = Kubernetes.IoK8sApiStorageV1beta1CSINodeSpec - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const AzureFilePersistentVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFilePersistentVolumeSource - const SecretReference = Kubernetes.IoK8sApiCoreV1SecretReference - const StorageClass = Kubernetes.IoK8sApiStorageV1beta1StorageClass - const CSINodeDriver = Kubernetes.IoK8sApiStorageV1beta1CSINodeDriver - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const CSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CSIPersistentVolumeSource - end - module AutoscalingV2beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ExternalMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta1ExternalMetricSource - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const PodsMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta1PodsMetricSource - const ResourceMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta1ResourceMetricStatus - const MetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta1MetricStatus - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const HorizontalPodAutoscalerCondition = Kubernetes.IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerCondition - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const ExternalMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta1ExternalMetricStatus - const CrossVersionObjectReference = Kubernetes.IoK8sApiAutoscalingV2beta1CrossVersionObjectReference - const ResourceMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta1ResourceMetricSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const ObjectMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta1ObjectMetricStatus - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const PodsMetricStatus = Kubernetes.IoK8sApiAutoscalingV2beta1PodsMetricStatus - const MetricSpec = Kubernetes.IoK8sApiAutoscalingV2beta1MetricSpec - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const HorizontalPodAutoscalerList = Kubernetes.IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerList - const HorizontalPodAutoscalerSpec = Kubernetes.IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerSpec - const HorizontalPodAutoscaler = Kubernetes.IoK8sApiAutoscalingV2beta1HorizontalPodAutoscaler - const HorizontalPodAutoscalerStatus = Kubernetes.IoK8sApiAutoscalingV2beta1HorizontalPodAutoscalerStatus - const ObjectMetricSource = Kubernetes.IoK8sApiAutoscalingV2beta1ObjectMetricSource - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module SchedulingV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const PriorityClassList = Kubernetes.IoK8sApiSchedulingV1PriorityClassList - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const PriorityClass = Kubernetes.IoK8sApiSchedulingV1PriorityClass - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module ApiregistrationV1beta1 - using ..Kubernetes - const ServiceReference = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1ServiceReference - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const APIServiceCondition = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceCondition - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIServiceList = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceList - const APIServiceStatus = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceStatus - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const APIServiceSpec = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIServiceSpec - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const APIService = Kubernetes.IoK8sKubeAggregatorPkgApisApiregistrationV1beta1APIService - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module FlowcontrolApiserverV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const NonResourcePolicyRule = Kubernetes.IoK8sApiFlowcontrolV1alpha1NonResourcePolicyRule - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const FlowDistinguisherMethod = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowDistinguisherMethod - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const Subject = Kubernetes.IoK8sApiFlowcontrolV1alpha1Subject - const LimitResponse = Kubernetes.IoK8sApiFlowcontrolV1alpha1LimitResponse - const UserSubject = Kubernetes.IoK8sApiFlowcontrolV1alpha1UserSubject - const PriorityLevelConfiguration = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfiguration - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const FlowSchema = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowSchema - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const LimitedPriorityLevelConfiguration = Kubernetes.IoK8sApiFlowcontrolV1alpha1LimitedPriorityLevelConfiguration - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const PriorityLevelConfigurationSpec = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationSpec - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const QueuingConfiguration = Kubernetes.IoK8sApiFlowcontrolV1alpha1QueuingConfiguration - const FlowSchemaCondition = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowSchemaCondition - const GroupSubject = Kubernetes.IoK8sApiFlowcontrolV1alpha1GroupSubject - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const PriorityLevelConfigurationReference = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationReference - const ServiceAccountSubject = Kubernetes.IoK8sApiFlowcontrolV1alpha1ServiceAccountSubject - const FlowSchemaList = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowSchemaList - const PolicyRulesWithSubjects = Kubernetes.IoK8sApiFlowcontrolV1alpha1PolicyRulesWithSubjects - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const PriorityLevelConfigurationList = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationList - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const FlowSchemaStatus = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowSchemaStatus - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const FlowSchemaSpec = Kubernetes.IoK8sApiFlowcontrolV1alpha1FlowSchemaSpec - const PriorityLevelConfigurationStatus = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationStatus - const ResourcePolicyRule = Kubernetes.IoK8sApiFlowcontrolV1alpha1ResourcePolicyRule - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PriorityLevelConfigurationCondition = Kubernetes.IoK8sApiFlowcontrolV1alpha1PriorityLevelConfigurationCondition - end - module AdmissionregistrationV1 - using ..Kubernetes - const MutatingWebhook = Kubernetes.IoK8sApiAdmissionregistrationV1MutatingWebhook - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const MutatingWebhookConfiguration = Kubernetes.IoK8sApiAdmissionregistrationV1MutatingWebhookConfiguration - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const WebhookClientConfig = Kubernetes.IoK8sApiAdmissionregistrationV1WebhookClientConfig - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const ValidatingWebhookConfiguration = Kubernetes.IoK8sApiAdmissionregistrationV1ValidatingWebhookConfiguration - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const RuleWithOperations = Kubernetes.IoK8sApiAdmissionregistrationV1RuleWithOperations - const ValidatingWebhook = Kubernetes.IoK8sApiAdmissionregistrationV1ValidatingWebhook - const ServiceReference = Kubernetes.IoK8sApiAdmissionregistrationV1ServiceReference - const MutatingWebhookConfigurationList = Kubernetes.IoK8sApiAdmissionregistrationV1MutatingWebhookConfigurationList - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const ValidatingWebhookConfigurationList = Kubernetes.IoK8sApiAdmissionregistrationV1ValidatingWebhookConfigurationList - end - module CustomMetricsV1beta1 - using ..Kubernetes - const MetricValue = Kubernetes.IoK8sApiCustomMetricsV1beta1MetricValue - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const MetricValueList = Kubernetes.IoK8sApiCustomMetricsV1beta1MetricValueList - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - end - module AutoscalingV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const HorizontalPodAutoscaler = Kubernetes.IoK8sApiAutoscalingV1HorizontalPodAutoscaler - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const HorizontalPodAutoscalerSpec = Kubernetes.IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const HorizontalPodAutoscalerStatus = Kubernetes.IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const HorizontalPodAutoscalerList = Kubernetes.IoK8sApiAutoscalingV1HorizontalPodAutoscalerList - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const CrossVersionObjectReference = Kubernetes.IoK8sApiAutoscalingV1CrossVersionObjectReference - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module ApiextensionsV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const CustomResourceValidation = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const WebhookClientConfig = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const CustomResourceDefinitionSpec = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec - const CustomResourceSubresourceScale = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale - const ExternalDocumentation = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation - const CustomResourceDefinition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition - const CustomResourceColumnDefinition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition - const CustomResourceDefinitionNames = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const CustomResourceSubresources = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources - const CustomResourceDefinitionList = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const ServiceReference = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const CustomResourceConversion = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const WebhookConversion = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion - const CustomResourceDefinitionVersion = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion - const JSONSchemaProps = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const CustomResourceDefinitionCondition = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition - const CustomResourceDefinitionStatus = Kubernetes.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module StorageV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const VolumeAttachmentSource = Kubernetes.IoK8sApiStorageV1alpha1VolumeAttachmentSource - const CinderPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CinderPersistentVolumeSource - const ScaleIOPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOPersistentVolumeSource - const VolumeAttachmentSpec = Kubernetes.IoK8sApiStorageV1alpha1VolumeAttachmentSpec - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const StorageOSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSPersistentVolumeSource - const VolumeAttachment = Kubernetes.IoK8sApiStorageV1alpha1VolumeAttachment - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const VolumeAttachmentList = Kubernetes.IoK8sApiStorageV1alpha1VolumeAttachmentList - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LocalVolumeSource = Kubernetes.IoK8sApiCoreV1LocalVolumeSource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const VolumeError = Kubernetes.IoK8sApiStorageV1alpha1VolumeError - const ISCSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIPersistentVolumeSource - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const CephFSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSPersistentVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const PersistentVolumeSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const GlusterfsPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsPersistentVolumeSource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RBDPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1RBDPersistentVolumeSource - const VolumeNodeAffinity = Kubernetes.IoK8sApiCoreV1VolumeNodeAffinity - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const VolumeAttachmentStatus = Kubernetes.IoK8sApiStorageV1alpha1VolumeAttachmentStatus - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const FlexPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1FlexPersistentVolumeSource - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const AzureFilePersistentVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFilePersistentVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const SecretReference = Kubernetes.IoK8sApiCoreV1SecretReference - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const CSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CSIPersistentVolumeSource - end - module AppsV1beta1 - using ..Kubernetes - const ScaleSpec = Kubernetes.IoK8sApiAppsV1beta1ScaleSpec - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const StatefulSet = Kubernetes.IoK8sApiAppsV1beta1StatefulSet - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const StatefulSetStatus = Kubernetes.IoK8sApiAppsV1beta1StatefulSetStatus - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const Deployment = Kubernetes.IoK8sApiAppsV1beta1Deployment - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const ControllerRevisionList = Kubernetes.IoK8sApiAppsV1beta1ControllerRevisionList - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const PersistentVolumeClaimStatus = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimStatus - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const RollingUpdateDeployment = Kubernetes.IoK8sApiAppsV1beta1RollingUpdateDeployment - const ScaleStatus = Kubernetes.IoK8sApiAppsV1beta1ScaleStatus - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TypedLocalObjectReference = Kubernetes.IoK8sApiCoreV1TypedLocalObjectReference - const StatefulSetCondition = Kubernetes.IoK8sApiAppsV1beta1StatefulSetCondition - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const DeploymentStatus = Kubernetes.IoK8sApiAppsV1beta1DeploymentStatus - const PersistentVolumeClaimSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimSpec - const PersistentVolumeClaimCondition = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimCondition - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const StatefulSetList = Kubernetes.IoK8sApiAppsV1beta1StatefulSetList - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const StatefulSetUpdateStrategy = Kubernetes.IoK8sApiAppsV1beta1StatefulSetUpdateStrategy - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const Scale = Kubernetes.IoK8sApiAppsV1beta1Scale - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatefulSetSpec = Kubernetes.IoK8sApiAppsV1beta1StatefulSetSpec - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const DeploymentSpec = Kubernetes.IoK8sApiAppsV1beta1DeploymentSpec - const PersistentVolumeClaim = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaim - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const DeploymentCondition = Kubernetes.IoK8sApiAppsV1beta1DeploymentCondition - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const DeploymentList = Kubernetes.IoK8sApiAppsV1beta1DeploymentList - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const ControllerRevision = Kubernetes.IoK8sApiAppsV1beta1ControllerRevision - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const RollingUpdateStatefulSetStrategy = Kubernetes.IoK8sApiAppsV1beta1RollingUpdateStatefulSetStrategy - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const DeploymentStrategy = Kubernetes.IoK8sApiAppsV1beta1DeploymentStrategy - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const RollbackConfig = Kubernetes.IoK8sApiAppsV1beta1RollbackConfig - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end - module CoreV1 - using ..Kubernetes - const CinderPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CinderPersistentVolumeSource - const NodeConfigSource = Kubernetes.IoK8sApiCoreV1NodeConfigSource - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const LimitRangeSpec = Kubernetes.IoK8sApiCoreV1LimitRangeSpec - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const ServiceStatus = Kubernetes.IoK8sApiCoreV1ServiceStatus - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const NodeSystemInfo = Kubernetes.IoK8sApiCoreV1NodeSystemInfo - const ReplicationController = Kubernetes.IoK8sApiCoreV1ReplicationController - const LimitRangeItem = Kubernetes.IoK8sApiCoreV1LimitRangeItem - const ScopedResourceSelectorRequirement = Kubernetes.IoK8sApiCoreV1ScopedResourceSelectorRequirement - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const PodTemplate = Kubernetes.IoK8sApiCoreV1PodTemplate - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const LoadBalancerIngress = Kubernetes.IoK8sApiCoreV1LoadBalancerIngress - const DeleteOptions = Kubernetes.IoK8sApimachineryPkgApisMetaV1DeleteOptions - const ContainerStatus = Kubernetes.IoK8sApiCoreV1ContainerStatus - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const Binding = Kubernetes.IoK8sApiCoreV1Binding - const Node = Kubernetes.IoK8sApiCoreV1Node - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NamespaceCondition = Kubernetes.IoK8sApiCoreV1NamespaceCondition - const Preconditions = Kubernetes.IoK8sApimachineryPkgApisMetaV1Preconditions - const NodeCondition = Kubernetes.IoK8sApiCoreV1NodeCondition - const NamespaceStatus = Kubernetes.IoK8sApiCoreV1NamespaceStatus - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const ISCSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIPersistentVolumeSource - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const PersistentVolumeSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeSpec - const EndpointPort = Kubernetes.IoK8sApiCoreV1EndpointPort - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const Namespace = Kubernetes.IoK8sApiCoreV1Namespace - const RBDPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1RBDPersistentVolumeSource - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const SecretList = Kubernetes.IoK8sApiCoreV1SecretList - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const ReplicationControllerSpec = Kubernetes.IoK8sApiCoreV1ReplicationControllerSpec - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const FlexPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1FlexPersistentVolumeSource - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TypedLocalObjectReference = Kubernetes.IoK8sApiCoreV1TypedLocalObjectReference - const NodeDaemonEndpoints = Kubernetes.IoK8sApiCoreV1NodeDaemonEndpoints - const NodeList = Kubernetes.IoK8sApiCoreV1NodeList - const PersistentVolumeClaimSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimSpec - const PersistentVolumeClaimCondition = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimCondition - const ComponentStatusList = Kubernetes.IoK8sApiCoreV1ComponentStatusList - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const StorageOSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSPersistentVolumeSource - const EndpointsList = Kubernetes.IoK8sApiCoreV1EndpointsList - const PodList = Kubernetes.IoK8sApiCoreV1PodList - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ReplicationControllerCondition = Kubernetes.IoK8sApiCoreV1ReplicationControllerCondition - const EndpointSubset = Kubernetes.IoK8sApiCoreV1EndpointSubset - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const TokenRequestStatus = Kubernetes.IoK8sApiAuthenticationV1TokenRequestStatus - const ServiceSpec = Kubernetes.IoK8sApiCoreV1ServiceSpec - const DaemonEndpoint = Kubernetes.IoK8sApiCoreV1DaemonEndpoint - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const LocalVolumeSource = Kubernetes.IoK8sApiCoreV1LocalVolumeSource - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const CephFSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSPersistentVolumeSource - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ServicePort = Kubernetes.IoK8sApiCoreV1ServicePort - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const Endpoints = Kubernetes.IoK8sApiCoreV1Endpoints - const NamespaceSpec = Kubernetes.IoK8sApiCoreV1NamespaceSpec - const EventList = Kubernetes.IoK8sApiCoreV1EventList - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ContainerStateRunning = Kubernetes.IoK8sApiCoreV1ContainerStateRunning - const PodCondition = Kubernetes.IoK8sApiCoreV1PodCondition - const PersistentVolumeList = Kubernetes.IoK8sApiCoreV1PersistentVolumeList - const Scale = Kubernetes.IoK8sApiAutoscalingV1Scale - const VolumeNodeAffinity = Kubernetes.IoK8sApiCoreV1VolumeNodeAffinity - const NodeStatus = Kubernetes.IoK8sApiCoreV1NodeStatus - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const TokenRequestSpec = Kubernetes.IoK8sApiAuthenticationV1TokenRequestSpec - const SecretReference = Kubernetes.IoK8sApiCoreV1SecretReference - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const NodeConfigStatus = Kubernetes.IoK8sApiCoreV1NodeConfigStatus - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const NodeAddress = Kubernetes.IoK8sApiCoreV1NodeAddress - const Container = Kubernetes.IoK8sApiCoreV1Container - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const ScaleIOPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOPersistentVolumeSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const EndpointAddress = Kubernetes.IoK8sApiCoreV1EndpointAddress - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const PersistentVolumeClaimList = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimList - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const Pod = Kubernetes.IoK8sApiCoreV1Pod - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ContainerStateTerminated = Kubernetes.IoK8sApiCoreV1ContainerStateTerminated - const LoadBalancerStatus = Kubernetes.IoK8sApiCoreV1LoadBalancerStatus - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const Taint = Kubernetes.IoK8sApiCoreV1Taint - const SessionAffinityConfig = Kubernetes.IoK8sApiCoreV1SessionAffinityConfig - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const Event = Kubernetes.IoK8sApiCoreV1Event - const NamespaceList = Kubernetes.IoK8sApiCoreV1NamespaceList - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const Eviction = Kubernetes.IoK8sApiPolicyV1beta1Eviction - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const ConfigMap = Kubernetes.IoK8sApiCoreV1ConfigMap - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const NodeSpec = Kubernetes.IoK8sApiCoreV1NodeSpec - const ComponentCondition = Kubernetes.IoK8sApiCoreV1ComponentCondition - const TokenRequest = Kubernetes.IoK8sApiAuthenticationV1TokenRequest - const PersistentVolumeClaimStatus = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimStatus - const ResourceQuota = Kubernetes.IoK8sApiCoreV1ResourceQuota - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const GlusterfsPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsPersistentVolumeSource - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const ConfigMapNodeConfigSource = Kubernetes.IoK8sApiCoreV1ConfigMapNodeConfigSource - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const ServiceAccountList = Kubernetes.IoK8sApiCoreV1ServiceAccountList - const ResourceQuotaList = Kubernetes.IoK8sApiCoreV1ResourceQuotaList - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const Secret = Kubernetes.IoK8sApiCoreV1Secret - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ContainerState = Kubernetes.IoK8sApiCoreV1ContainerState - const LimitRangeList = Kubernetes.IoK8sApiCoreV1LimitRangeList - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const PersistentVolume = Kubernetes.IoK8sApiCoreV1PersistentVolume - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const PersistentVolumeStatus = Kubernetes.IoK8sApiCoreV1PersistentVolumeStatus - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const ServiceList = Kubernetes.IoK8sApiCoreV1ServiceList - const CSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CSIPersistentVolumeSource - const ReplicationControllerList = Kubernetes.IoK8sApiCoreV1ReplicationControllerList - const BoundObjectReference = Kubernetes.IoK8sApiAuthenticationV1BoundObjectReference - const ResourceQuotaSpec = Kubernetes.IoK8sApiCoreV1ResourceQuotaSpec - const AttachedVolume = Kubernetes.IoK8sApiCoreV1AttachedVolume - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const EventSeries = Kubernetes.IoK8sApiCoreV1EventSeries - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const PodStatus = Kubernetes.IoK8sApiCoreV1PodStatus - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const ReplicationControllerStatus = Kubernetes.IoK8sApiCoreV1ReplicationControllerStatus - const ConfigMapList = Kubernetes.IoK8sApiCoreV1ConfigMapList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const EventSource = Kubernetes.IoK8sApiCoreV1EventSource - const ContainerStateWaiting = Kubernetes.IoK8sApiCoreV1ContainerStateWaiting - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const PodIP = Kubernetes.IoK8sApiCoreV1PodIP - const ContainerImage = Kubernetes.IoK8sApiCoreV1ContainerImage - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const ResourceQuotaStatus = Kubernetes.IoK8sApiCoreV1ResourceQuotaStatus - const ScaleSpec = Kubernetes.IoK8sApiAutoscalingV1ScaleSpec - const ScaleStatus = Kubernetes.IoK8sApiAutoscalingV1ScaleStatus - const ClientIPConfig = Kubernetes.IoK8sApiCoreV1ClientIPConfig - const PersistentVolumeClaim = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaim - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const LimitRange = Kubernetes.IoK8sApiCoreV1LimitRange - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ServiceAccount = Kubernetes.IoK8sApiCoreV1ServiceAccount - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const AzureFilePersistentVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFilePersistentVolumeSource - const PodTemplateList = Kubernetes.IoK8sApiCoreV1PodTemplateList - const ComponentStatus = Kubernetes.IoK8sApiCoreV1ComponentStatus - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const Service = Kubernetes.IoK8sApiCoreV1Service - const ScopeSelector = Kubernetes.IoK8sApiCoreV1ScopeSelector - end - module AuthenticationV1 - using ..Kubernetes - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const TokenReviewStatus = Kubernetes.IoK8sApiAuthenticationV1TokenReviewStatus - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const TokenReviewSpec = Kubernetes.IoK8sApiAuthenticationV1TokenReviewSpec - const UserInfo = Kubernetes.IoK8sApiAuthenticationV1UserInfo - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const TokenReview = Kubernetes.IoK8sApiAuthenticationV1TokenReview - end - module NetworkingV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const NetworkPolicyIngressRule = Kubernetes.IoK8sApiNetworkingV1NetworkPolicyIngressRule - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const NetworkPolicyEgressRule = Kubernetes.IoK8sApiNetworkingV1NetworkPolicyEgressRule - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const NetworkPolicyList = Kubernetes.IoK8sApiNetworkingV1NetworkPolicyList - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const NetworkPolicyPort = Kubernetes.IoK8sApiNetworkingV1NetworkPolicyPort - const NetworkPolicySpec = Kubernetes.IoK8sApiNetworkingV1NetworkPolicySpec - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const NetworkPolicy = Kubernetes.IoK8sApiNetworkingV1NetworkPolicy - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const NetworkPolicyPeer = Kubernetes.IoK8sApiNetworkingV1NetworkPolicyPeer - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const IPBlock = Kubernetes.IoK8sApiNetworkingV1IPBlock - end - module SchedulingV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PriorityClassList = Kubernetes.IoK8sApiSchedulingV1beta1PriorityClassList - const PriorityClass = Kubernetes.IoK8sApiSchedulingV1beta1PriorityClass - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module BatchV2alpha1 - using ..Kubernetes - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const CronJob = Kubernetes.IoK8sApiBatchV2alpha1CronJob - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const CronJobList = Kubernetes.IoK8sApiBatchV2alpha1CronJobList - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const JobSpec = Kubernetes.IoK8sApiBatchV1JobSpec - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const CronJobStatus = Kubernetes.IoK8sApiBatchV2alpha1CronJobStatus - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const JobTemplateSpec = Kubernetes.IoK8sApiBatchV2alpha1JobTemplateSpec - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const CronJobSpec = Kubernetes.IoK8sApiBatchV2alpha1CronJobSpec - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end - module NodeV1beta1 - using ..Kubernetes - const RuntimeClassList = Kubernetes.IoK8sApiNodeV1beta1RuntimeClassList - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const Scheduling = Kubernetes.IoK8sApiNodeV1beta1Scheduling - const Overhead = Kubernetes.IoK8sApiNodeV1beta1Overhead - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const RuntimeClass = Kubernetes.IoK8sApiNodeV1beta1RuntimeClass - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AppsV1 - using ..Kubernetes - const Container = Kubernetes.IoK8sApiCoreV1Container - const ReplicaSetSpec = Kubernetes.IoK8sApiAppsV1ReplicaSetSpec - const ReplicaSet = Kubernetes.IoK8sApiAppsV1ReplicaSet - const StatefulSet = Kubernetes.IoK8sApiAppsV1StatefulSet - const ReplicaSetList = Kubernetes.IoK8sApiAppsV1ReplicaSetList - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const DeploymentStrategy = Kubernetes.IoK8sApiAppsV1DeploymentStrategy - const RollingUpdateDaemonSet = Kubernetes.IoK8sApiAppsV1RollingUpdateDaemonSet - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const DaemonSet = Kubernetes.IoK8sApiAppsV1DaemonSet - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const ControllerRevision = Kubernetes.IoK8sApiAppsV1ControllerRevision - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const StatefulSetSpec = Kubernetes.IoK8sApiAppsV1StatefulSetSpec - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DeploymentSpec = Kubernetes.IoK8sApiAppsV1DeploymentSpec - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const PersistentVolumeClaimStatus = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimStatus - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const DaemonSetCondition = Kubernetes.IoK8sApiAppsV1DaemonSetCondition - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const DeploymentList = Kubernetes.IoK8sApiAppsV1DeploymentList - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TypedLocalObjectReference = Kubernetes.IoK8sApiCoreV1TypedLocalObjectReference - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const DaemonSetList = Kubernetes.IoK8sApiAppsV1DaemonSetList - const DaemonSetSpec = Kubernetes.IoK8sApiAppsV1DaemonSetSpec - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const PersistentVolumeClaimSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimSpec - const PersistentVolumeClaimCondition = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimCondition - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const DaemonSetStatus = Kubernetes.IoK8sApiAppsV1DaemonSetStatus - const StatefulSetStatus = Kubernetes.IoK8sApiAppsV1StatefulSetStatus - const RollingUpdateDeployment = Kubernetes.IoK8sApiAppsV1RollingUpdateDeployment - const StatefulSetCondition = Kubernetes.IoK8sApiAppsV1StatefulSetCondition - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const DaemonSetUpdateStrategy = Kubernetes.IoK8sApiAppsV1DaemonSetUpdateStrategy - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const ReplicaSetCondition = Kubernetes.IoK8sApiAppsV1ReplicaSetCondition - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const Deployment = Kubernetes.IoK8sApiAppsV1Deployment - const DeploymentStatus = Kubernetes.IoK8sApiAppsV1DeploymentStatus - const ScaleSpec = Kubernetes.IoK8sApiAutoscalingV1ScaleSpec - const ScaleStatus = Kubernetes.IoK8sApiAutoscalingV1ScaleStatus - const PersistentVolumeClaim = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaim - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const RollingUpdateStatefulSetStrategy = Kubernetes.IoK8sApiAppsV1RollingUpdateStatefulSetStrategy - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const ControllerRevisionList = Kubernetes.IoK8sApiAppsV1ControllerRevisionList - const ReplicaSetStatus = Kubernetes.IoK8sApiAppsV1ReplicaSetStatus - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const DeploymentCondition = Kubernetes.IoK8sApiAppsV1DeploymentCondition - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const Scale = Kubernetes.IoK8sApiAutoscalingV1Scale - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const StatefulSetList = Kubernetes.IoK8sApiAppsV1StatefulSetList - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const StatefulSetUpdateStrategy = Kubernetes.IoK8sApiAppsV1StatefulSetUpdateStrategy - end - module RbacAuthorizationV1alpha1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const ClusterRoleBindingList = Kubernetes.IoK8sApiRbacV1alpha1ClusterRoleBindingList - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const ClusterRole = Kubernetes.IoK8sApiRbacV1alpha1ClusterRole - const RoleBinding = Kubernetes.IoK8sApiRbacV1alpha1RoleBinding - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const RoleRef = Kubernetes.IoK8sApiRbacV1alpha1RoleRef - const RoleBindingList = Kubernetes.IoK8sApiRbacV1alpha1RoleBindingList - const Role = Kubernetes.IoK8sApiRbacV1alpha1Role - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const Subject = Kubernetes.IoK8sApiRbacV1alpha1Subject - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const ClusterRoleList = Kubernetes.IoK8sApiRbacV1alpha1ClusterRoleList - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const PolicyRule = Kubernetes.IoK8sApiRbacV1alpha1PolicyRule - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const AggregationRule = Kubernetes.IoK8sApiRbacV1alpha1AggregationRule - const ClusterRoleBinding = Kubernetes.IoK8sApiRbacV1alpha1ClusterRoleBinding - const RoleList = Kubernetes.IoK8sApiRbacV1alpha1RoleList - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module DiscoveryV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const EndpointSliceList = Kubernetes.IoK8sApiDiscoveryV1beta1EndpointSliceList - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const EndpointConditions = Kubernetes.IoK8sApiDiscoveryV1beta1EndpointConditions - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const EndpointSlice = Kubernetes.IoK8sApiDiscoveryV1beta1EndpointSlice - const Endpoint = Kubernetes.IoK8sApiDiscoveryV1beta1Endpoint - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const EndpointPort = Kubernetes.IoK8sApiDiscoveryV1beta1EndpointPort - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AuditregistrationV1alpha1 - using ..Kubernetes - const AuditSinkSpec = Kubernetes.IoK8sApiAuditregistrationV1alpha1AuditSinkSpec - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const AuditSink = Kubernetes.IoK8sApiAuditregistrationV1alpha1AuditSink - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const WebhookClientConfig = Kubernetes.IoK8sApiAuditregistrationV1alpha1WebhookClientConfig - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const AuditSinkList = Kubernetes.IoK8sApiAuditregistrationV1alpha1AuditSinkList - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const Policy = Kubernetes.IoK8sApiAuditregistrationV1alpha1Policy - const Webhook = Kubernetes.IoK8sApiAuditregistrationV1alpha1Webhook - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const WebhookThrottleConfig = Kubernetes.IoK8sApiAuditregistrationV1alpha1WebhookThrottleConfig - const ServiceReference = Kubernetes.IoK8sApiAuditregistrationV1alpha1ServiceReference - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module KarpenterShV1alpha5 - using ..Kubernetes - const sh_karpenter_v1alpha5_Provisioner_spec_requirements_inner = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecRequirementsInner - const sh_karpenter_v1alpha5_Provisioner_spec_limits = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecLimits - const sh_karpenter_v1alpha5_Provisioner_spec = Kubernetes.ShKarpenterV1alpha5ProvisionerSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const sh_karpenter_v1alpha5_Provisioner_spec_startupTaints_inner = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecStartupTaintsInner - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const sh_karpenter_v1alpha5_Provisioner_status = Kubernetes.ShKarpenterV1alpha5ProvisionerStatus - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const sh_karpenter_v1alpha5_Provisioner_spec_kubeletConfiguration = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecKubeletConfiguration - const Status_v2 = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusV2 - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const ProvisionerList = Kubernetes.ShKarpenterV1alpha5ProvisionerList - const Provisioner = Kubernetes.ShKarpenterV1alpha5Provisioner - const sh_karpenter_v1alpha5_Provisioner_spec_providerRef = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecProviderRef - const StatusDetails_v2 = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetailsV2 - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const sh_karpenter_v1alpha5_Provisioner_spec_consolidation = Kubernetes.ShKarpenterV1alpha5ProvisionerSpecConsolidation - const sh_karpenter_v1alpha5_Provisioner_status_conditions_inner = Kubernetes.ShKarpenterV1alpha5ProvisionerStatusConditionsInner - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module NetworkingV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const IngressStatus = Kubernetes.IoK8sApiNetworkingV1beta1IngressStatus - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const IngressTLS = Kubernetes.IoK8sApiNetworkingV1beta1IngressTLS - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const Ingress = Kubernetes.IoK8sApiNetworkingV1beta1Ingress - const LoadBalancerStatus = Kubernetes.IoK8sApiCoreV1LoadBalancerStatus - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const HTTPIngressPath = Kubernetes.IoK8sApiNetworkingV1beta1HTTPIngressPath - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const IngressSpec = Kubernetes.IoK8sApiNetworkingV1beta1IngressSpec - const HTTPIngressRuleValue = Kubernetes.IoK8sApiNetworkingV1beta1HTTPIngressRuleValue - const IngressList = Kubernetes.IoK8sApiNetworkingV1beta1IngressList - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const LoadBalancerIngress = Kubernetes.IoK8sApiCoreV1LoadBalancerIngress - const IngressRule = Kubernetes.IoK8sApiNetworkingV1beta1IngressRule - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const IngressBackend = Kubernetes.IoK8sApiNetworkingV1beta1IngressBackend - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - end - module AdmissionregistrationV1beta1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const ValidatingWebhook = Kubernetes.IoK8sApiAdmissionregistrationV1beta1ValidatingWebhook - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const ServiceReference = Kubernetes.IoK8sApiAdmissionregistrationV1beta1ServiceReference - const ValidatingWebhookConfiguration = Kubernetes.IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfiguration - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const MutatingWebhook = Kubernetes.IoK8sApiAdmissionregistrationV1beta1MutatingWebhook - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const MutatingWebhookConfigurationList = Kubernetes.IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfigurationList - const RuleWithOperations = Kubernetes.IoK8sApiAdmissionregistrationV1beta1RuleWithOperations - const MutatingWebhookConfiguration = Kubernetes.IoK8sApiAdmissionregistrationV1beta1MutatingWebhookConfiguration - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const ValidatingWebhookConfigurationList = Kubernetes.IoK8sApiAdmissionregistrationV1beta1ValidatingWebhookConfigurationList - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const WebhookClientConfig = Kubernetes.IoK8sApiAdmissionregistrationV1beta1WebhookClientConfig - end - module StorageV1 - using ..Kubernetes - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const CSINodeDriver = Kubernetes.IoK8sApiStorageV1CSINodeDriver - const CinderPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CinderPersistentVolumeSource - const ScaleIOPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOPersistentVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const StorageOSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSPersistentVolumeSource - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const TopologySelectorLabelRequirement = Kubernetes.IoK8sApiCoreV1TopologySelectorLabelRequirement - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const TopologySelectorTerm = Kubernetes.IoK8sApiCoreV1TopologySelectorTerm - const VolumeAttachmentStatus = Kubernetes.IoK8sApiStorageV1VolumeAttachmentStatus - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const VolumeError = Kubernetes.IoK8sApiStorageV1VolumeError - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const LocalVolumeSource = Kubernetes.IoK8sApiCoreV1LocalVolumeSource - const VolumeAttachmentSource = Kubernetes.IoK8sApiStorageV1VolumeAttachmentSource - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const CSINodeSpec = Kubernetes.IoK8sApiStorageV1CSINodeSpec - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const StorageClassList = Kubernetes.IoK8sApiStorageV1StorageClassList - const ISCSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIPersistentVolumeSource - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const CephFSPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSPersistentVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const PersistentVolumeSpec = Kubernetes.IoK8sApiCoreV1PersistentVolumeSpec - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const VolumeNodeResources = Kubernetes.IoK8sApiStorageV1VolumeNodeResources - const ObjectReference = Kubernetes.IoK8sApiCoreV1ObjectReference - const GlusterfsPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsPersistentVolumeSource - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RBDPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1RBDPersistentVolumeSource - const VolumeNodeAffinity = Kubernetes.IoK8sApiCoreV1VolumeNodeAffinity - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const CSINode = Kubernetes.IoK8sApiStorageV1CSINode - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const FlexPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1FlexPersistentVolumeSource - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const VolumeAttachmentList = Kubernetes.IoK8sApiStorageV1VolumeAttachmentList - const AzureFilePersistentVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFilePersistentVolumeSource - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const SecretReference = Kubernetes.IoK8sApiCoreV1SecretReference - const StorageClass = Kubernetes.IoK8sApiStorageV1StorageClass - const VolumeAttachment = Kubernetes.IoK8sApiStorageV1VolumeAttachment - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const VolumeAttachmentSpec = Kubernetes.IoK8sApiStorageV1VolumeAttachmentSpec - const CSIPersistentVolumeSource = Kubernetes.IoK8sApiCoreV1CSIPersistentVolumeSource - const CSINodeList = Kubernetes.IoK8sApiStorageV1CSINodeList - end - module ExtensionsV1beta1 - using ..Kubernetes - const IngressList = Kubernetes.IoK8sApiExtensionsV1beta1IngressList - const SecurityContext = Kubernetes.IoK8sApiCoreV1SecurityContext - const Capabilities = Kubernetes.IoK8sApiCoreV1Capabilities - const SecretEnvSource = Kubernetes.IoK8sApiCoreV1SecretEnvSource - const PodSpec = Kubernetes.IoK8sApiCoreV1PodSpec - const ObjectFieldSelector = Kubernetes.IoK8sApiCoreV1ObjectFieldSelector - const Affinity = Kubernetes.IoK8sApiCoreV1Affinity - const ReplicaSetSpec = Kubernetes.IoK8sApiExtensionsV1beta1ReplicaSetSpec - const CinderVolumeSource = Kubernetes.IoK8sApiCoreV1CinderVolumeSource - const GroupVersionForDiscovery = Kubernetes.IoK8sApimachineryPkgApisMetaV1GroupVersionForDiscovery - const PodReadinessGate = Kubernetes.IoK8sApiCoreV1PodReadinessGate - const ReplicaSet = Kubernetes.IoK8sApiExtensionsV1beta1ReplicaSet - const LoadBalancerStatus = Kubernetes.IoK8sApiCoreV1LoadBalancerStatus - const Status = Kubernetes.IoK8sApimachineryPkgApisMetaV1Status - const GlusterfsVolumeSource = Kubernetes.IoK8sApiCoreV1GlusterfsVolumeSource - const AzureFileVolumeSource = Kubernetes.IoK8sApiCoreV1AzureFileVolumeSource - const LabelSelector = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelector - const RollingUpdateDeployment = Kubernetes.IoK8sApiExtensionsV1beta1RollingUpdateDeployment - const AzureDiskVolumeSource = Kubernetes.IoK8sApiCoreV1AzureDiskVolumeSource - const NetworkPolicyPort = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicyPort - const IDRange = Kubernetes.IoK8sApiExtensionsV1beta1IDRange - const Volume = Kubernetes.IoK8sApiCoreV1Volume - const ScaleSpec = Kubernetes.IoK8sApiExtensionsV1beta1ScaleSpec - const FCVolumeSource = Kubernetes.IoK8sApiCoreV1FCVolumeSource - const LoadBalancerIngress = Kubernetes.IoK8sApiCoreV1LoadBalancerIngress - const DaemonSetStatus = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSetStatus - const EnvVar = Kubernetes.IoK8sApiCoreV1EnvVar - const Deployment = Kubernetes.IoK8sApiExtensionsV1beta1Deployment - const LabelSelectorRequirement = Kubernetes.IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement - const NetworkPolicySpec = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicySpec - const APIResource = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResource - const RuntimeClassStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1RuntimeClassStrategyOptions - const ExecAction = Kubernetes.IoK8sApiCoreV1ExecAction - const DaemonSet = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSet - const NodeSelectorTerm = Kubernetes.IoK8sApiCoreV1NodeSelectorTerm - const DeploymentStatus = Kubernetes.IoK8sApiExtensionsV1beta1DeploymentStatus - const VolumeProjection = Kubernetes.IoK8sApiCoreV1VolumeProjection - const AllowedHostPath = Kubernetes.IoK8sApiExtensionsV1beta1AllowedHostPath - const OwnerReference = Kubernetes.IoK8sApimachineryPkgApisMetaV1OwnerReference - const PodDNSConfigOption = Kubernetes.IoK8sApiCoreV1PodDNSConfigOption - const PodAntiAffinity = Kubernetes.IoK8sApiCoreV1PodAntiAffinity - const EnvFromSource = Kubernetes.IoK8sApiCoreV1EnvFromSource - const TopologySpreadConstraint = Kubernetes.IoK8sApiCoreV1TopologySpreadConstraint - const NetworkPolicy = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicy - const FlexVolumeSource = Kubernetes.IoK8sApiCoreV1FlexVolumeSource - const FlockerVolumeSource = Kubernetes.IoK8sApiCoreV1FlockerVolumeSource - const StatusDetails = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusDetails - const DownwardAPIProjection = Kubernetes.IoK8sApiCoreV1DownwardAPIProjection - const KeyToPath = Kubernetes.IoK8sApiCoreV1KeyToPath - const DeploymentList = Kubernetes.IoK8sApiExtensionsV1beta1DeploymentList - const ResourceRequirements = Kubernetes.IoK8sApiCoreV1ResourceRequirements - const Lifecycle = Kubernetes.IoK8sApiCoreV1Lifecycle - const Handler = Kubernetes.IoK8sApiCoreV1Handler - const RBDVolumeSource = Kubernetes.IoK8sApiCoreV1RBDVolumeSource - const StorageOSVolumeSource = Kubernetes.IoK8sApiCoreV1StorageOSVolumeSource - const AllowedFlexVolume = Kubernetes.IoK8sApiExtensionsV1beta1AllowedFlexVolume - const EnvVarSource = Kubernetes.IoK8sApiCoreV1EnvVarSource - const ProjectedVolumeSource = Kubernetes.IoK8sApiCoreV1ProjectedVolumeSource - const NetworkPolicyPeer = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicyPeer - const PodAffinity = Kubernetes.IoK8sApiCoreV1PodAffinity - const GitRepoVolumeSource = Kubernetes.IoK8sApiCoreV1GitRepoVolumeSource - const IngressRule = Kubernetes.IoK8sApiExtensionsV1beta1IngressRule - const PodTemplateSpec = Kubernetes.IoK8sApiCoreV1PodTemplateSpec - const Scale = Kubernetes.IoK8sApiExtensionsV1beta1Scale - const VsphereVirtualDiskVolumeSource = Kubernetes.IoK8sApiCoreV1VsphereVirtualDiskVolumeSource - const SecretProjection = Kubernetes.IoK8sApiCoreV1SecretProjection - const FSGroupStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1FSGroupStrategyOptions - const Probe = Kubernetes.IoK8sApiCoreV1Probe - const HostAlias = Kubernetes.IoK8sApiCoreV1HostAlias - const TCPSocketAction = Kubernetes.IoK8sApiCoreV1TCPSocketAction - const Toleration = Kubernetes.IoK8sApiCoreV1Toleration - const NodeAffinity = Kubernetes.IoK8sApiCoreV1NodeAffinity - const HTTPIngressRuleValue = Kubernetes.IoK8sApiExtensionsV1beta1HTTPIngressRuleValue - const ConfigMapVolumeSource = Kubernetes.IoK8sApiCoreV1ConfigMapVolumeSource - const ScaleStatus = Kubernetes.IoK8sApiExtensionsV1beta1ScaleStatus - const PodSecurityPolicy = Kubernetes.IoK8sApiExtensionsV1beta1PodSecurityPolicy - const WatchEvent = Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - const ReplicaSetCondition = Kubernetes.IoK8sApiExtensionsV1beta1ReplicaSetCondition - const ReplicaSetList = Kubernetes.IoK8sApiExtensionsV1beta1ReplicaSetList - const IngressBackend = Kubernetes.IoK8sApiExtensionsV1beta1IngressBackend - const Sysctl = Kubernetes.IoK8sApiCoreV1Sysctl - const ScaleIOVolumeSource = Kubernetes.IoK8sApiCoreV1ScaleIOVolumeSource - const IngressSpec = Kubernetes.IoK8sApiExtensionsV1beta1IngressSpec - const ContainerPort = Kubernetes.IoK8sApiCoreV1ContainerPort - const EphemeralContainer = Kubernetes.IoK8sApiCoreV1EphemeralContainer - const DaemonSetSpec = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSetSpec - const SELinuxOptions = Kubernetes.IoK8sApiCoreV1SELinuxOptions - const ObjectMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ObjectMeta - const Ingress = Kubernetes.IoK8sApiExtensionsV1beta1Ingress - const WeightedPodAffinityTerm = Kubernetes.IoK8sApiCoreV1WeightedPodAffinityTerm - const WindowsSecurityContextOptions = Kubernetes.IoK8sApiCoreV1WindowsSecurityContextOptions - const IngressStatus = Kubernetes.IoK8sApiExtensionsV1beta1IngressStatus - const SupplementalGroupsStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1SupplementalGroupsStrategyOptions - const GCEPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1GCEPersistentDiskVolumeSource - const ManagedFieldsEntry = Kubernetes.IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry - const NetworkPolicyList = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicyList - const IngressTLS = Kubernetes.IoK8sApiExtensionsV1beta1IngressTLS - const NodeSelector = Kubernetes.IoK8sApiCoreV1NodeSelector - const PodSecurityContext = Kubernetes.IoK8sApiCoreV1PodSecurityContext - const DownwardAPIVolumeFile = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeFile - const NFSVolumeSource = Kubernetes.IoK8sApiCoreV1NFSVolumeSource - const RunAsGroupStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1RunAsGroupStrategyOptions - const ResourceFieldSelector = Kubernetes.IoK8sApiCoreV1ResourceFieldSelector - const ConfigMapEnvSource = Kubernetes.IoK8sApiCoreV1ConfigMapEnvSource - const AllowedCSIDriver = Kubernetes.IoK8sApiExtensionsV1beta1AllowedCSIDriver - const PodSecurityPolicySpec = Kubernetes.IoK8sApiExtensionsV1beta1PodSecurityPolicySpec - const ReplicaSetStatus = Kubernetes.IoK8sApiExtensionsV1beta1ReplicaSetStatus - const RunAsUserStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1RunAsUserStrategyOptions - const NetworkPolicyEgressRule = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicyEgressRule - const IPBlock = Kubernetes.IoK8sApiExtensionsV1beta1IPBlock - const HostPathVolumeSource = Kubernetes.IoK8sApiCoreV1HostPathVolumeSource - const DeploymentSpec = Kubernetes.IoK8sApiExtensionsV1beta1DeploymentSpec - const SELinuxStrategyOptions = Kubernetes.IoK8sApiExtensionsV1beta1SELinuxStrategyOptions - const QuobyteVolumeSource = Kubernetes.IoK8sApiCoreV1QuobyteVolumeSource - const APIGroupList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroupList - const NodeSelectorRequirement = Kubernetes.IoK8sApiCoreV1NodeSelectorRequirement - const LocalObjectReference = Kubernetes.IoK8sApiCoreV1LocalObjectReference - const ConfigMapProjection = Kubernetes.IoK8sApiCoreV1ConfigMapProjection - const DownwardAPIVolumeSource = Kubernetes.IoK8sApiCoreV1DownwardAPIVolumeSource - const ISCSIVolumeSource = Kubernetes.IoK8sApiCoreV1ISCSIVolumeSource - const NetworkPolicyIngressRule = Kubernetes.IoK8sApiExtensionsV1beta1NetworkPolicyIngressRule - const PreferredSchedulingTerm = Kubernetes.IoK8sApiCoreV1PreferredSchedulingTerm - const ListMeta = Kubernetes.IoK8sApimachineryPkgApisMetaV1ListMeta - const PodDNSConfig = Kubernetes.IoK8sApiCoreV1PodDNSConfig - const AWSElasticBlockStoreVolumeSource = Kubernetes.IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource - const APIGroup = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIGroup - const RollingUpdateDaemonSet = Kubernetes.IoK8sApiExtensionsV1beta1RollingUpdateDaemonSet - const HTTPHeader = Kubernetes.IoK8sApiCoreV1HTTPHeader - const DaemonSetList = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSetList - const DeploymentCondition = Kubernetes.IoK8sApiExtensionsV1beta1DeploymentCondition - const HostPortRange = Kubernetes.IoK8sApiExtensionsV1beta1HostPortRange - const DaemonSetCondition = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSetCondition - const SecretKeySelector = Kubernetes.IoK8sApiCoreV1SecretKeySelector - const DeploymentStrategy = Kubernetes.IoK8sApiExtensionsV1beta1DeploymentStrategy - const PortworxVolumeSource = Kubernetes.IoK8sApiCoreV1PortworxVolumeSource - const CephFSVolumeSource = Kubernetes.IoK8sApiCoreV1CephFSVolumeSource - const HTTPIngressPath = Kubernetes.IoK8sApiExtensionsV1beta1HTTPIngressPath - const CSIVolumeSource = Kubernetes.IoK8sApiCoreV1CSIVolumeSource - const SecretVolumeSource = Kubernetes.IoK8sApiCoreV1SecretVolumeSource - const APIResourceList = Kubernetes.IoK8sApimachineryPkgApisMetaV1APIResourceList - const DaemonSetUpdateStrategy = Kubernetes.IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy - const EmptyDirVolumeSource = Kubernetes.IoK8sApiCoreV1EmptyDirVolumeSource - const PodSecurityPolicyList = Kubernetes.IoK8sApiExtensionsV1beta1PodSecurityPolicyList - const RollbackConfig = Kubernetes.IoK8sApiExtensionsV1beta1RollbackConfig - const StatusCause = Kubernetes.IoK8sApimachineryPkgApisMetaV1StatusCause - const PersistentVolumeClaimVolumeSource = Kubernetes.IoK8sApiCoreV1PersistentVolumeClaimVolumeSource - const PodAffinityTerm = Kubernetes.IoK8sApiCoreV1PodAffinityTerm - const ServiceAccountTokenProjection = Kubernetes.IoK8sApiCoreV1ServiceAccountTokenProjection - const ServerAddressByClientCIDR = Kubernetes.IoK8sApimachineryPkgApisMetaV1ServerAddressByClientCIDR - const VolumeDevice = Kubernetes.IoK8sApiCoreV1VolumeDevice - const VolumeMount = Kubernetes.IoK8sApiCoreV1VolumeMount - const HTTPGetAction = Kubernetes.IoK8sApiCoreV1HTTPGetAction - const ConfigMapKeySelector = Kubernetes.IoK8sApiCoreV1ConfigMapKeySelector - const PhotonPersistentDiskVolumeSource = Kubernetes.IoK8sApiCoreV1PhotonPersistentDiskVolumeSource - const Container = Kubernetes.IoK8sApiCoreV1Container - end -end diff --git a/src/ApiImpl/api_versions.jl b/src/ApiImpl/api_versions.jl deleted file mode 100644 index b89b23e6..00000000 --- a/src/ApiImpl/api_versions.jl +++ /dev/null @@ -1,2516 +0,0 @@ -const APIVersionMap = Dict( - "settings.k8s.io/v1alpha1" => "SettingsV1alpha1Api", - "networking.k8s.io/v1" => "NetworkingV1Api", - "apiextensions.k8s.io/v1beta1" => "ApiextensionsV1beta1Api", - "apps/v1beta2" => "AppsV1beta2Api", - "scheduling.k8s.io/v1" => "SchedulingV1Api", - "rbac.authorization.k8s.io/v1" => "RbacAuthorizationV1Api", - "apiextensions.k8s.io/v1" => "ApiextensionsV1Api", - "scheduling.k8s.io/v1beta1" => "SchedulingV1beta1Api", - "batch/v2alpha1" => "BatchV2alpha1Api", - "apps/v1beta1" => "AppsV1beta1Api", - "discovery.k8s.io/v1beta1" => "DiscoveryV1beta1Api", - "storage.k8s.io/v1beta1" => "StorageV1beta1Api", - "authorization.k8s.io/v1beta1" => "AuthorizationV1beta1Api", - "autoscaling/v1" => "AutoscalingV1Api", - "coordination.k8s.io/v1beta1" => "CoordinationV1beta1Api", - "v1" => "CoreV1Api", - "autoscaling/v2beta2" => "AutoscalingV2beta2Api", - "authentication.k8s.io/v1" => "AuthenticationV1Api", - "apps/v1" => "AppsV1Api", - "rbac.authorization.k8s.io/v1alpha1" => "RbacAuthorizationV1alpha1Api", - "admissionregistration.k8s.io/v1beta1" => "AdmissionregistrationV1beta1Api", - "apiregistration.k8s.io/v1beta1" => "ApiregistrationV1beta1Api", - "events.k8s.io/v1beta1" => "EventsV1beta1Api", - "auditregistration.k8s.io/v1alpha1" => "AuditregistrationV1alpha1Api", - "karpenter.sh/v1alpha5" => "KarpenterShV1alpha5Api", - "node.k8s.io/v1alpha1" => "NodeV1alpha1Api", - "policy/v1beta1" => "PolicyV1beta1Api", - "storage.k8s.io/v1alpha1" => "StorageV1alpha1Api", - "storage.k8s.io/v1" => "StorageV1Api", - "autoscaling/v2beta1" => "AutoscalingV2beta1Api", - "metrics.k8s.io/v1beta1" => "MetricsV1beta1Api", - "authentication.k8s.io/v1beta1" => "AuthenticationV1beta1Api", - "rbac.authorization.k8s.io/v1beta1" => "RbacAuthorizationV1beta1Api", - "admissionregistration.k8s.io/v1" => "AdmissionregistrationV1Api", - "batch/v1" => "BatchV1Api", - "scheduling.k8s.io/v1alpha1" => "SchedulingV1alpha1Api", - "batch/v1beta1" => "BatchV1beta1Api", - "flowcontrol.apiserver.k8s.io/v1alpha1" => "FlowcontrolApiserverV1alpha1Api", - "authorization.k8s.io/v1" => "AuthorizationV1Api", - "extensions/v1beta1" => "ExtensionsV1beta1Api", - "apis" => "ApisApi", - "coordination.k8s.io/v1" => "CoordinationV1Api", - "apiregistration.k8s.io/v1" => "ApiregistrationV1Api", - "certificates.k8s.io/v1beta1" => "CertificatesV1beta1Api", - "node.k8s.io/v1beta1" => "NodeV1beta1Api", - "custom.metrics.k8s.io/v1beta1" => "CustomMetricsV1beta1Api", - "networking.k8s.io/v1beta1" => "NetworkingV1beta1Api", -) - -# patch_namespaced_limit_range -patch_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_patch_namespaced_pod_proxy_with_path -connect_patch_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_replication_controller -delete_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_pod_disruption_budget_status -patch_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.patch_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# connect_patch_namespaced_pod_proxy -connect_patch_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_stateful_set -watch_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# delete_collection_priority_level_configuration -delete_collection_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.delete_flowcontrol_apiserver_v1alpha1_collection_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# replace_namespaced_event -replace_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -replace_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.replace_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# watch_a_p_i_service -watch_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.watch_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -watch_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# list_persistent_volume -list_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_lease -patch_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.patch_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -patch_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.patch_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# replace_c_s_i_node -replace_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.replace_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -replace_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.replace_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# connect_head_node_proxy -connect_head_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_pod_template -delete_collection_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_pod_disruption_budget -patch_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.patch_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_replication_controller -delete_collection_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_event -watch_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -watch_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.watch_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# read_namespaced_role -read_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -read_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -read_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# read_namespaced_role_binding -read_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -read_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -read_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# replace_node_status -replace_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_replica_set_list -watch_namespaced_replica_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_replica_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_replica_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_replica_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_replica_set_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_replica_set_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_role_binding -watch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_mutating_webhook_configuration -delete_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -delete_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# read_persistent_volume -read_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_service_account -delete_collection_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_flow_schema_status -patch_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.patch_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# watch_c_s_i_driver -watch_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# list_namespaced_config_map -list_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_job -delete_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.delete_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# list_lease_for_all_namespaces -list_lease_for_all_namespaces(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.list_coordination_v1_lease_for_all_namespaces(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -list_lease_for_all_namespaces(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.list_coordination_v1beta1_lease_for_all_namespaces(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# read_namespaced_ingress_status -read_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -read_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.read_networking_v1beta1_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_priority_level_configuration_status -read_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.read_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# delete_collection_a_p_i_service -delete_collection_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.delete_apiregistration_v1_collection_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -delete_collection_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_apiregistration_v1beta1_collection_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# watch_pod_preset_list_for_all_namespaces -watch_pod_preset_list_for_all_namespaces(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.watch_settings_v1alpha1_pod_preset_list_for_all_namespaces(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# create_namespaced_horizontal_pod_autoscaler -create_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.create_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -create_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.create_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -create_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.create_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# connect_head_namespaced_pod_proxy_with_path -connect_head_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_pod_disruption_budget_for_all_namespaces -list_pod_disruption_budget_for_all_namespaces(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.list_policy_v1beta1_pod_disruption_budget_for_all_namespaces(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# list_namespaced_endpoints -list_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_get_node_proxy_with_path -connect_get_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_limit_range_list_for_all_namespaces -watch_limit_range_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_limit_range_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_pod_metrics -list_pod_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) = Kubernetes.list_metrics_v1beta1_pod_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) - -# watch_namespaced_endpoints_list -watch_namespaced_endpoints_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_endpoints_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_endpoint_slice_list_for_all_namespaces -watch_endpoint_slice_list_for_all_namespaces(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.watch_discovery_v1beta1_endpoint_slice_list_for_all_namespaces(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# create_namespaced_limit_range -create_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_limit_range_for_all_namespaces -list_limit_range_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_limit_range_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_certificate_signing_request -list_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.list_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# connect_head_node_proxy_with_path -connect_head_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_stateful_set_list_for_all_namespaces -watch_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_stateful_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# replace_namespaced_network_policy -replace_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -replace_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.replace_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# list_volume_attachment -list_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.list_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -list_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.list_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -list_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.list_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# replace_custom_resource_definition -replace_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.replace_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -replace_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_replica_set -watch_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_namespaced_deployment -list_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_storage_class -list_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.list_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -list_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.list_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# read_namespaced_horizontal_pod_autoscaler_status -read_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.read_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -read_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -read_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# patch_flow_schema -patch_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.patch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# replace_volume_attachment_status -replace_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.replace_storage_v1_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) - -# read_validating_webhook_configuration -read_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.read_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -read_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.read_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# watch_namespaced_service_account -watch_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_priority_class -create_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.create_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -create_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.create_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -create_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.create_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# patch_volume_attachment_status -patch_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.patch_storage_v1_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) - -# delete_collection_mutating_webhook_configuration -delete_collection_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1_collection_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -delete_collection_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1beta1_collection_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# read_namespaced_resource_quota -read_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_stateful_set_status -replace_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_event_list_for_all_namespaces -watch_event_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_event_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) -watch_event_list_for_all_namespaces(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.watch_events_v1beta1_event_list_for_all_namespaces(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# patch_persistent_volume_status -patch_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_pod_template -replace_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_endpoint_slice_list -watch_namespaced_endpoint_slice_list(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.watch_discovery_v1beta1_namespaced_endpoint_slice_list(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# list_provisioner -list_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.list_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# list_namespaced_pod_template -list_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_horizontal_pod_autoscaler -replace_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -replace_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -replace_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# delete_namespaced_stateful_set -delete_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# list_replica_set_for_all_namespaces -list_replica_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_replica_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_replica_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_replica_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_replica_set_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_replica_set_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# create_pod_security_policy -create_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -create_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.create_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# read_namespaced_endpoint_slice -read_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.read_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# delete_namespaced_service -delete_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_replica_set -patch_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_stateful_set_scale -replace_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_get_namespaced_pod_proxy -connect_get_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_get_namespaced_pod_proxy_with_path -connect_get_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_provisioner -delete_collection_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.delete_karpenter_sh_v1alpha5_collection_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# patch_namespaced_role_binding -patch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -patch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -patch_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_custom_resource_definition_list -watch_custom_resource_definition_list(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.watch_apiextensions_v1_custom_resource_definition_list(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -watch_custom_resource_definition_list(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apiextensions_v1beta1_custom_resource_definition_list(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# read_namespaced_replication_controller_scale -read_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_horizontal_pod_autoscaler -delete_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v1_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -delete_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v2beta1_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -delete_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v2beta2_collection_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# watch_c_s_i_node_list -watch_c_s_i_node_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_c_s_i_node_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_c_s_i_node_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_c_s_i_node_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# create_namespace -create_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_provisioner_status -replace_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.replace_karpenter_sh_v1alpha5_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# create_validating_webhook_configuration -create_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.create_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -create_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.create_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# connect_patch_node_proxy -connect_patch_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_pod_disruption_budget_status -replace_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.replace_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# watch_deployment_list_for_all_namespaces -watch_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_deployment_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_deployment_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_deployment_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# connect_delete_namespaced_service_proxy_with_path -connect_delete_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_get_node_proxy -connect_get_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_get_namespaced_service_proxy_with_path -connect_get_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_a_p_i_service -delete_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.delete_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -delete_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# watch_config_map_list_for_all_namespaces -watch_config_map_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_config_map_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_provisioner -replace_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.replace_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# delete_collection_namespaced_role -delete_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_collection_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_certificate_signing_request_list -watch_certificate_signing_request_list(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.watch_certificates_v1beta1_certificate_signing_request_list(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# list_role_binding_for_all_namespaces -list_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_role_binding_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_namespaced_secret_list -watch_namespaced_secret_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_secret_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_replication_controller_scale -patch_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_a_p_i_service -create_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.create_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -create_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.create_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# create_namespaced_persistent_volume_claim -create_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_pod_for_all_namespaces -list_pod_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_pod_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_certificate_signing_request -create_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.create_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# replace_namespaced_replication_controller -replace_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_node_metrics -list_node_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) = Kubernetes.list_metrics_v1beta1_node_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) - -# delete_collection_node -delete_collection_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_pod -patch_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_replica_set -read_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_volume_attachment -delete_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.delete_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -delete_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_controller_revision_list_for_all_namespaces -watch_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_controller_revision_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_namespaced_endpoints -watch_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_custom_resource_definition_status -patch_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.patch_apiextensions_v1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -patch_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apiextensions_v1beta1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# delete_namespaced_deployment -delete_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_limit_range_list -watch_namespaced_limit_range_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_limit_range_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_cluster_role_list -watch_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_cluster_role_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_replica_set -delete_collection_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_collection_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_collection_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_collection_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_collection_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_namespaced_persistent_volume_claim_status -patch_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_network_policy -create_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -create_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.create_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# read_namespace -read_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_custom_resource_definition_status -read_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.read_apiextensions_v1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -read_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_apiextensions_v1beta1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# watch_priority_class -watch_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -watch_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -watch_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_cron_job -delete_collection_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.delete_batch_v1_collection_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -delete_collection_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.delete_batch_v1beta1_collection_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -delete_collection_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.delete_batch_v2alpha1_collection_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# read_namespaced_pod -read_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_validating_webhook_configuration_list -watch_validating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1_validating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -watch_validating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1beta1_validating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# create_namespaced_local_subject_access_review -create_namespaced_local_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) = Kubernetes.create_authorization_v1_namespaced_local_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) -create_namespaced_local_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_authorization_v1beta1_namespaced_local_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) - -# list_job_for_all_namespaces -list_job_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.list_batch_v1_job_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# watch_network_policy_list_for_all_namespaces -watch_network_policy_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_network_policy_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_network_policy_list_for_all_namespaces(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.watch_networking_v1_network_policy_list_for_all_namespaces(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# delete_cluster_role_binding -delete_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_namespaced_stateful_set_list -watch_namespaced_stateful_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_stateful_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_stateful_set_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_stateful_set_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_stateful_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_stateful_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# patch_namespaced_job_status -patch_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.patch_batch_v1_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# patch_namespaced_service_account -patch_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_role -watch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# create_namespaced_service_account_token -create_namespaced_service_account_token(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_service_account_token(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_cluster_role -patch_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -patch_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -patch_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_namespaced_job_list -watch_namespaced_job_list(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_namespaced_job_list(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# watch_namespaced_service_account_list -watch_namespaced_service_account_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_service_account_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_lease -delete_collection_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.delete_coordination_v1_collection_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -delete_collection_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.delete_coordination_v1beta1_collection_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# create_namespaced_service -create_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_node -replace_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_daemon_set_list -watch_namespaced_daemon_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_daemon_set_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_daemon_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_daemon_set_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_daemon_set_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_daemon_set_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_cluster_role_binding -patch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -patch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -patch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# create_volume_attachment -create_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.create_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -create_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.create_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -create_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.create_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# patch_namespaced_endpoint_slice -patch_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.patch_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# patch_namespaced_config_map -patch_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_cron_job_status -replace_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.replace_batch_v1_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) -replace_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.replace_batch_v1beta1_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -replace_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.replace_batch_v2alpha1_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# read_namespaced_deployment_scale -read_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# connect_get_namespaced_pod_portforward -connect_get_namespaced_pod_portforward(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_pod_portforward(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_pod_template -read_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_endpoints -create_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_cluster_role -delete_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_cron_job_for_all_namespaces -list_cron_job_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.list_batch_v1_cron_job_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) -list_cron_job_for_all_namespaces(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.list_batch_v1beta1_cron_job_for_all_namespaces(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -list_cron_job_for_all_namespaces(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.list_batch_v2alpha1_cron_job_for_all_namespaces(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# replace_pod_security_policy -replace_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -replace_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.replace_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_collection_certificate_signing_request -delete_collection_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.delete_certificates_v1beta1_collection_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# read_c_s_i_node -read_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.read_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -read_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.read_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# patch_namespaced_pod_preset -patch_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.patch_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# replace_namespaced_daemon_set -replace_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_service -watch_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_validating_webhook_configuration -list_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.list_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -list_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.list_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# patch_namespaced_event -patch_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -patch_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.patch_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# replace_priority_level_configuration_status -replace_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# read_namespaced_replica_set_scale -read_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# connect_put_node_proxy_with_path -connect_put_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_daemon_set -delete_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_horizontal_pod_autoscaler_list_for_all_namespaces -watch_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -watch_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta1_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -watch_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta2_horizontal_pod_autoscaler_list_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# list_namespaced_replication_controller -list_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_node_status -read_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_pod_status -patch_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_service -read_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_limit_range -replace_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_pod_preset -replace_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.replace_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# read_a_p_i_service_status -read_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.read_apiregistration_v1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -read_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.read_apiregistration_v1beta1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# list_namespaced_secret -list_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_event -create_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -create_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.create_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# delete_namespaced_endpoints -delete_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_pod_security_policy -delete_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.delete_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# read_namespaced_deployment -read_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_replication_controller_status -replace_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_custom_resource_definition -create_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.create_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -create_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_network_policy -delete_collection_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_collection_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.delete_networking_v1_collection_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# read_runtime_class -read_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.read_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -read_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.read_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# patch_namespaced_secret -patch_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_replication_controller_list_for_all_namespaces -watch_replication_controller_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_replication_controller_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_network_policy_for_all_namespaces -list_network_policy_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_network_policy_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -list_network_policy_for_all_namespaces(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.list_networking_v1_network_policy_for_all_namespaces(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# read_persistent_volume_status -read_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_delete_namespaced_pod_proxy -connect_delete_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_post_namespaced_service_proxy_with_path -connect_post_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_options_node_proxy_with_path -connect_options_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_pod_template -watch_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_replication_controller -create_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_secret_list_for_all_namespaces -watch_secret_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_secret_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_stateful_set_scale -read_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# create_namespaced_daemon_set -create_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.create_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -create_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.create_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -create_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_namespaced_controller_revision -delete_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_head_namespaced_pod_proxy -connect_head_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_pod -delete_collection_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_flow_schema -delete_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.delete_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# connect_post_namespaced_pod_proxy_with_path -connect_post_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_delete_namespaced_pod_proxy_with_path -connect_delete_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_horizontal_pod_autoscaler_for_all_namespaces -list_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.list_autoscaling_v1_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -list_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.list_autoscaling_v2beta1_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -list_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.list_autoscaling_v2beta2_horizontal_pod_autoscaler_for_all_namespaces(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# connect_post_node_proxy_with_path -connect_post_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_job -list_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.list_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# read_namespaced_controller_revision -read_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# get_a_p_i_versions -get_a_p_i_versions(_api::Kubernetes.ApisApi, args...; kwargs...) = Kubernetes.get_a_p_i_versions(_api::Kubernetes.ApisApi, args...; kwargs...) - -# read_namespaced_event -read_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -read_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.read_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# list_ingress_for_all_namespaces -list_ingress_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_ingress_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -list_ingress_for_all_namespaces(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.list_networking_v1beta1_ingress_for_all_namespaces(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# watch_namespaced_lease_list -watch_namespaced_lease_list(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1_namespaced_lease_list(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -watch_namespaced_lease_list(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1beta1_namespaced_lease_list(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# patch_certificate_signing_request_status -patch_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.patch_certificates_v1beta1_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# watch_namespaced_pod_list -watch_namespaced_pod_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_pod_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_options_namespaced_service_proxy_with_path -connect_options_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_endpoint_slice -create_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.create_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# delete_priority_class -delete_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -delete_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -delete_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# list_mutating_webhook_configuration -list_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.list_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -list_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.list_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_controller_revision -delete_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_collection_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# patch_custom_resource_definition -patch_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.patch_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -patch_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# connect_options_namespaced_pod_proxy -connect_options_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_pod_disruption_budget_list -watch_namespaced_pod_disruption_budget_list(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.watch_policy_v1beta1_namespaced_pod_disruption_budget_list(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# patch_audit_sink -patch_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.patch_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# replace_persistent_volume_status -replace_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_persistent_volume_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_controller_revision -watch_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_options_namespaced_service_proxy -connect_options_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_deployment_status -replace_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# create_namespaced_pod_template -create_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_pod_security_policy -delete_collection_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_collection_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.delete_policy_v1beta1_collection_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# list_persistent_volume_claim_for_all_namespaces -list_persistent_volume_claim_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_persistent_volume_claim_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_flow_schema_list -watch_flow_schema_list(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.watch_flowcontrol_apiserver_v1alpha1_flow_schema_list(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# list_namespaced_role_binding -list_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_storage_class -watch_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_namespaced_event_list -watch_namespaced_event_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_event_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) -watch_namespaced_event_list(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.watch_events_v1beta1_namespaced_event_list(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# watch_persistent_volume -watch_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_replication_controller_status -read_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_certificate_signing_request -delete_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.delete_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# patch_a_p_i_service_status -patch_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.patch_apiregistration_v1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -patch_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.patch_apiregistration_v1beta1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# connect_delete_node_proxy_with_path -connect_delete_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespace_status -replace_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_cron_job -read_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.read_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -read_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.read_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -read_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.read_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# replace_namespaced_pod -replace_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_post_namespaced_pod_attach -connect_post_namespaced_pod_attach(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_pod_attach(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_cluster_role_binding -delete_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_collection_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_c_s_i_node -watch_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# create_namespaced_controller_revision -create_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.create_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -create_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.create_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -create_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.create_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_namespaced_controller_revision_list -watch_namespaced_controller_revision_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_controller_revision_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_controller_revision_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_controller_revision_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_controller_revision_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_controller_revision_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# list_namespace -list_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_pod_disruption_budget -list_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.list_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_collection_storage_class -delete_collection_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_collection_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_collection_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_collection_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_c_s_i_driver -delete_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_namespaced_limit_range -watch_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_options_namespaced_pod_proxy_with_path -connect_options_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_cluster_role -delete_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_collection_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# replace_namespaced_stateful_set -replace_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# replace_namespaced_pod_status -replace_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_custom_resource_definition_status -replace_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.replace_apiextensions_v1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -replace_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apiextensions_v1beta1_custom_resource_definition_status(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_daemon_set -watch_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# connect_post_namespaced_service_proxy -connect_post_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_replica_set_status -patch_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_namespaced_pod_template -patch_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_a_p_i_service_status -replace_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.replace_apiregistration_v1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -replace_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.replace_apiregistration_v1beta1_a_p_i_service_status(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# list_pod_security_policy -list_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -list_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.list_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# create_namespaced_lease -create_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.create_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -create_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.create_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# patch_namespaced_stateful_set_status -patch_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# read_namespaced_pod_status -read_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_pod_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_network_policy -watch_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.watch_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# read_namespaced_daemon_set -read_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# get_a_p_i_resources -get_a_p_i_resources(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.get_admissionregistration_v1_a_p_i_resources(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.get_admissionregistration_v1beta1_a_p_i_resources(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.get_apiextensions_v1_a_p_i_resources(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.get_apiextensions_v1beta1_a_p_i_resources(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.get_apiregistration_v1_a_p_i_resources(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.get_apiregistration_v1beta1_a_p_i_resources(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.get_apps_v1_a_p_i_resources(_api::Kubernetes.AppsV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.get_apps_v1beta1_a_p_i_resources(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.get_apps_v1beta2_a_p_i_resources(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.get_auditregistration_v1alpha1_a_p_i_resources(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AuthenticationV1Api, args...; kwargs...) = Kubernetes.get_authentication_v1_a_p_i_resources(_api::Kubernetes.AuthenticationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AuthenticationV1beta1Api, args...; kwargs...) = Kubernetes.get_authentication_v1beta1_a_p_i_resources(_api::Kubernetes.AuthenticationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) = Kubernetes.get_authorization_v1_a_p_i_resources(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.get_authorization_v1beta1_a_p_i_resources(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.get_autoscaling_v1_a_p_i_resources(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.get_autoscaling_v2beta1_a_p_i_resources(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.get_autoscaling_v2beta2_a_p_i_resources(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.get_batch_v1_a_p_i_resources(_api::Kubernetes.BatchV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.get_batch_v1beta1_a_p_i_resources(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.get_batch_v2alpha1_a_p_i_resources(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.get_certificates_v1beta1_a_p_i_resources(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.get_coordination_v1_a_p_i_resources(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.get_coordination_v1beta1_a_p_i_resources(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.get_core_v1_a_p_i_resources(_api::Kubernetes.CoreV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.get_discovery_v1beta1_a_p_i_resources(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.get_events_v1beta1_a_p_i_resources(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.get_extensions_v1beta1_a_p_i_resources(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.get_flowcontrol_apiserver_v1alpha1_a_p_i_resources(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.get_networking_v1_a_p_i_resources(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.get_networking_v1beta1_a_p_i_resources(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.get_node_v1alpha1_a_p_i_resources(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.get_node_v1beta1_a_p_i_resources(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.get_policy_v1beta1_a_p_i_resources(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.get_rbac_authorization_v1_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.get_rbac_authorization_v1alpha1_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.get_rbac_authorization_v1beta1_a_p_i_resources(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.get_scheduling_v1_a_p_i_resources(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.get_scheduling_v1alpha1_a_p_i_resources(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.get_scheduling_v1beta1_a_p_i_resources(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.get_settings_v1alpha1_a_p_i_resources(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.get_storage_v1_a_p_i_resources(_api::Kubernetes.StorageV1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.get_storage_v1alpha1_a_p_i_resources(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -get_a_p_i_resources(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.get_storage_v1beta1_a_p_i_resources(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# patch_namespaced_job -patch_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.patch_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# read_namespaced_config_map -read_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_cron_job_status -read_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.read_batch_v1_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) -read_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.read_batch_v1beta1_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -read_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.read_batch_v2alpha1_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# patch_node_status -patch_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_node_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_config_map -create_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_service_account -list_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_replica_set_status -replace_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_endpoint_slice -delete_collection_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.delete_discovery_v1beta1_collection_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# create_persistent_volume -create_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_job_status -replace_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.replace_batch_v1_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# read_namespaced_pod_metrics -read_namespaced_pod_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) = Kubernetes.read_metrics_v1beta1_namespaced_pod_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) - -# read_cluster_role -read_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -read_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -read_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# patch_runtime_class -patch_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.patch_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -patch_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.patch_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# replace_namespaced_secret -replace_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_secret -delete_collection_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_stateful_set_for_all_namespaces -list_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_stateful_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# patch_namespaced_cron_job_status -patch_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.patch_batch_v1_namespaced_cron_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) -patch_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.patch_batch_v1beta1_namespaced_cron_job_status(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -patch_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.patch_batch_v2alpha1_namespaced_cron_job_status(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# replace_cluster_role_binding -replace_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -replace_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -replace_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_namespaced_pod_preset -watch_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.watch_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# watch_namespaced_lease -watch_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -watch_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# replace_namespaced_controller_revision -replace_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# patch_namespaced_resource_quota_status -patch_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_endpoints_list_for_all_namespaces -watch_endpoints_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_endpoints_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_patch_namespaced_service_proxy -connect_patch_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_service_account -read_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_ingress -watch_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.watch_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# watch_c_s_i_driver_list -watch_c_s_i_driver_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_c_s_i_driver_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# read_component_status -read_component_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_component_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_deployment -replace_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_service_list -watch_namespaced_service_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_service_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_resource_quota_status -replace_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_config_map -replace_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_volume_attachment_list -watch_volume_attachment_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_volume_attachment_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_volume_attachment_list(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.watch_storage_v1alpha1_volume_attachment_list(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -watch_volume_attachment_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_volume_attachment_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# read_namespaced_secret -read_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_node -read_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_token_review -create_token_review(_api::Kubernetes.AuthenticationV1Api, args...; kwargs...) = Kubernetes.create_authentication_v1_token_review(_api::Kubernetes.AuthenticationV1Api, args...; kwargs...) -create_token_review(_api::Kubernetes.AuthenticationV1beta1Api, args...; kwargs...) = Kubernetes.create_authentication_v1beta1_token_review(_api::Kubernetes.AuthenticationV1beta1Api, args...; kwargs...) - -# watch_validating_webhook_configuration -watch_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -watch_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# create_namespaced_ingress -create_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -create_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.create_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# patch_namespaced_ingress_status -patch_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -patch_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.patch_networking_v1beta1_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# watch_priority_level_configuration -watch_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# read_cluster_role_binding -read_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -read_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -read_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.read_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# replace_cluster_role -replace_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -replace_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -replace_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_namespaced_secret -delete_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_provisioner -patch_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.patch_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# delete_collection_priority_class -delete_collection_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1_collection_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -delete_collection_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1alpha1_collection_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -delete_collection_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.delete_scheduling_v1beta1_collection_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# create_cluster_role -create_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -create_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -create_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_role_binding_list_for_all_namespaces -watch_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_role_binding_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_pod_preset -delete_collection_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.delete_settings_v1alpha1_collection_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# read_namespaced_replication_controller -read_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_priority_level_configuration -list_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.list_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# delete_namespaced_event -delete_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -delete_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.delete_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_endpoints -delete_collection_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_cron_job -delete_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.delete_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -delete_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.delete_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -delete_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.delete_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# list_namespaced_lease -list_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.list_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -list_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.list_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# watch_runtime_class_list -watch_runtime_class_list(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.watch_node_v1alpha1_runtime_class_list(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -watch_runtime_class_list(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.watch_node_v1beta1_runtime_class_list(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# replace_namespaced_role -replace_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -replace_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -replace_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_replica_set_list_for_all_namespaces -watch_replica_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_replica_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_replica_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_replica_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_replica_set_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_replica_set_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_storage_class -patch_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.patch_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -patch_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.patch_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_pod_disruption_budget_list_for_all_namespaces -watch_pod_disruption_budget_list_for_all_namespaces(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.watch_policy_v1beta1_pod_disruption_budget_list_for_all_namespaces(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_namespaced_role -delete_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# patch_namespaced_horizontal_pod_autoscaler -patch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -patch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -patch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# watch_namespace -watch_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_cluster_role_binding -watch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_namespaced_replica_set -delete_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_replication_controller_for_all_namespaces -list_replication_controller_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_replication_controller_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_provisioner -read_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.read_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# delete_collection_flow_schema -delete_collection_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.delete_flowcontrol_apiserver_v1alpha1_collection_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# connect_put_namespaced_pod_proxy -connect_put_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_post_namespaced_pod_exec -connect_post_namespaced_pod_exec(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_pod_exec(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_config_map -watch_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_network_policy -patch_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -patch_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.patch_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# read_flow_schema -read_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.read_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# list_deployment_for_all_namespaces -list_deployment_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_deployment_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_deployment_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_deployment_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_deployment_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_deployment_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_deployment_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_deployment_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# connect_put_namespaced_service_proxy -connect_put_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_ingress_status -replace_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_ingress_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -replace_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.replace_networking_v1beta1_namespaced_ingress_status(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# delete_collection_custom_resource_definition -delete_collection_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.delete_apiextensions_v1_collection_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -delete_collection_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apiextensions_v1beta1_collection_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# list_namespaced_replica_set -list_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_daemon_set_for_all_namespaces -list_daemon_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_daemon_set_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_daemon_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_daemon_set_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_daemon_set_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_daemon_set_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_cluster_role -watch_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# patch_volume_attachment -patch_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.patch_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -patch_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.patch_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -patch_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.patch_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_audit_sink -delete_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# read_namespaced_persistent_volume_claim_status -read_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_mutating_webhook_configuration_list -watch_mutating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1_mutating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -watch_mutating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1beta1_mutating_webhook_configuration_list(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# create_provisioner -create_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.create_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# read_namespaced_horizontal_pod_autoscaler -read_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.read_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -read_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.read_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -read_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.read_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# connect_head_namespaced_service_proxy_with_path -connect_head_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_controller_revision -patch_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# create_namespaced_secret -create_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_pod_disruption_budget -replace_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.replace_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# list_namespaced_horizontal_pod_autoscaler -list_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.list_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -list_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.list_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -list_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.list_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# create_namespaced_role -create_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -create_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -create_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# patch_mutating_webhook_configuration -patch_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.patch_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -patch_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.patch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# create_namespaced_pod_disruption_budget -create_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.create_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# read_namespaced_job -read_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.read_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# create_namespaced_resource_quota -create_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_priority_class_list -watch_priority_class_list(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1_priority_class_list(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -watch_priority_class_list(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1alpha1_priority_class_list(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -watch_priority_class_list(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.watch_scheduling_v1beta1_priority_class_list(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# create_self_subject_rules_review -create_self_subject_rules_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) = Kubernetes.create_authorization_v1_self_subject_rules_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) -create_self_subject_rules_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_authorization_v1beta1_self_subject_rules_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) - -# replace_certificate_signing_request -replace_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.replace_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# watch_ingress_list_for_all_namespaces -watch_ingress_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_ingress_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_ingress_list_for_all_namespaces(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.watch_networking_v1beta1_ingress_list_for_all_namespaces(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_namespaced_pod_preset -read_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.read_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# create_c_s_i_node -create_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.create_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -create_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.create_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_priority_level_configuration -delete_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.delete_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# delete_collection_namespaced_limit_range -delete_collection_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_replication_controller_dummy_scale -replace_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_network_policy_list -watch_namespaced_network_policy_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_network_policy_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_namespaced_network_policy_list(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.watch_networking_v1_namespaced_network_policy_list(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# list_audit_sink -list_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.list_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# create_runtime_class -create_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.create_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -create_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.create_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# watch_namespaced_pod_preset_list -watch_namespaced_pod_preset_list(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.watch_settings_v1alpha1_namespaced_pod_preset_list(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# delete_collection_namespaced_deployment -delete_collection_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_collection_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_collection_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_collection_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_collection_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_collection_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_collection_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# read_certificate_signing_request -read_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.read_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# list_priority_class -list_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.list_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -list_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.list_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -list_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.list_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# watch_audit_sink -watch_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# patch_namespaced_persistent_volume_claim -patch_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespace_status -patch_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_persistent_volume -patch_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_persistent_volume -delete_collection_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_endpoint_slice_for_all_namespaces -list_endpoint_slice_for_all_namespaces(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.list_discovery_v1beta1_endpoint_slice_for_all_namespaces(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# watch_namespace_list -watch_namespace_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespace_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_ingress_list -watch_namespaced_ingress_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_ingress_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_namespaced_ingress_list(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.watch_networking_v1beta1_namespaced_ingress_list(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_namespaced_job_status -read_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.read_batch_v1_namespaced_job_status(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# delete_runtime_class -delete_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.delete_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -delete_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.delete_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# replace_namespaced_ingress -replace_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -replace_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.replace_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# connect_patch_node_proxy_with_path -connect_patch_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_node_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_service_account -delete_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_cluster_role_binding -list_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# read_namespaced_persistent_volume_claim -read_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_service -list_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_secret -watch_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_secret(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_cron_job -create_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.create_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -create_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.create_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -create_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.create_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# read_flow_schema_status -read_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.read_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# read_namespaced_daemon_set_status -read_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_flow_schema -replace_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.replace_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# read_namespaced_pod_disruption_budget_status -read_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.read_policy_v1beta1_namespaced_pod_disruption_budget_status(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# replace_namespaced_persistent_volume_claim_status -replace_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_persistent_volume_claim_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_resource_quota_for_all_namespaces -list_resource_quota_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_resource_quota_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_validating_webhook_configuration -delete_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -delete_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# read_namespaced_stateful_set -read_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_post_namespaced_pod_proxy -connect_post_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_pod_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_pod_list_for_all_namespaces -watch_pod_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_pod_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_cron_job -watch_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -watch_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.watch_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -watch_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.watch_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# replace_namespaced_replica_set -replace_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# read_namespaced_pod_log -read_namespaced_pod_log(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_pod_log(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_stateful_set -patch_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_get_namespaced_pod_attach -connect_get_namespaced_pod_attach(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_pod_attach(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_resource_quota -replace_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_job -watch_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# create_namespaced_pod -create_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_priority_class -read_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.read_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -read_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.read_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -read_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.read_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# create_namespaced_stateful_set -create_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.create_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -create_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.create_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -create_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.create_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_flow_schema -watch_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.watch_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# create_namespaced_role_binding -create_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -create_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -create_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_pod_preset_for_all_namespaces -list_pod_preset_for_all_namespaces(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.list_settings_v1alpha1_pod_preset_for_all_namespaces(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# watch_volume_attachment -watch_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.watch_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -watch_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_namespaced_role_binding -delete_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_daemon_set_list_for_all_namespaces -watch_daemon_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_daemon_set_list_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_daemon_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_daemon_set_list_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_daemon_set_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_daemon_set_list_for_all_namespaces(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_audit_sink_list -watch_audit_sink_list(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_auditregistration_v1alpha1_audit_sink_list(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# connect_post_node_proxy -connect_post_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_node -create_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_custom_resource_definition -read_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.read_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -read_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_role_binding -delete_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -delete_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1alpha1_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -delete_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.delete_rbac_authorization_v1beta1_collection_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# connect_get_namespaced_pod_exec -connect_get_namespaced_pod_exec(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_pod_exec(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_resource_quota -delete_collection_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_delete_namespaced_service_proxy -connect_delete_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_cluster_role_binding_list -watch_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_cluster_role_binding_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_role_list_for_all_namespaces -watch_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_role_list_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# replace_certificate_signing_request_status -replace_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.replace_certificates_v1beta1_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# delete_namespaced_limit_range -delete_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_job -delete_collection_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.delete_batch_v1_collection_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# watch_job_list_for_all_namespaces -watch_job_list_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_job_list_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# delete_collection_namespaced_daemon_set -delete_collection_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_collection_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_collection_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_collection_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -delete_collection_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_resource_quota -watch_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_pod_binding -create_namespaced_pod_binding(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_pod_binding(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_config_map_list -watch_namespaced_config_map_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_config_map_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_secret_for_all_namespaces -list_secret_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_secret_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_custom_resource_definition -delete_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.delete_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -delete_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# watch_namespaced_cron_job_list -watch_namespaced_cron_job_list(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_namespaced_cron_job_list(_api::Kubernetes.BatchV1Api, args...; kwargs...) -watch_namespaced_cron_job_list(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.watch_batch_v1beta1_namespaced_cron_job_list(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -watch_namespaced_cron_job_list(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.watch_batch_v2alpha1_namespaced_cron_job_list(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# read_namespaced_service_status -read_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_ingress -read_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -read_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.read_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_namespaced_stateful_set_status -read_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_stateful_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# create_namespaced_deployment_rollback -create_namespaced_deployment_rollback(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.create_apps_v1beta1_namespaced_deployment_rollback(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -create_namespaced_deployment_rollback(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_deployment_rollback(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_collection_volume_attachment -delete_collection_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_collection_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_collection_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.delete_storage_v1alpha1_collection_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -delete_collection_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_collection_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# list_a_p_i_service -list_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.list_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -list_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.list_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# patch_namespaced_stateful_set_scale -patch_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_stateful_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# patch_a_p_i_service -patch_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.patch_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -patch_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.patch_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# read_namespaced_deployment_status -read_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.read_apps_v1beta1_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -read_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_validating_webhook_configuration -replace_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.replace_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -replace_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.replace_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# replace_audit_sink -replace_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.replace_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# delete_namespace -delete_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_replica_set_scale -patch_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_lease -replace_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.replace_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -replace_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.replace_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# patch_namespaced_cron_job -patch_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.patch_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -patch_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.patch_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -patch_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.patch_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# list_namespaced_event -list_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -list_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.list_events_v1beta1_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# list_namespaced_pod -list_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_namespaced_resource_quota_status -read_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_resource_quota_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_config_map -delete_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_pod_template_list -watch_namespaced_pod_template_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_pod_template_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_deployment -create_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.create_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -create_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.create_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -create_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.create_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -create_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# read_namespaced_replication_controller_dummy_scale -read_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# read_namespaced_replica_set_status -read_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.read_apps_v1_namespaced_replica_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -read_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.read_apps_v1beta2_namespaced_replica_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -read_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_replica_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_node -delete_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_validating_webhook_configuration -delete_collection_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1_collection_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -delete_collection_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.delete_admissionregistration_v1beta1_collection_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# watch_resource_quota_list_for_all_namespaces -watch_resource_quota_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_resource_quota_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_node_list -watch_node_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_node_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_pod_security_policy -patch_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -patch_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.patch_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# replace_namespaced_role_binding -replace_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -replace_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1alpha1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -replace_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.replace_rbac_authorization_v1beta1_namespaced_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_namespaced_stateful_set -list_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_namespaced_horizontal_pod_autoscaler -watch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -watch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -watch_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# list_service_account_for_all_namespaces -list_service_account_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_service_account_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_storage_class -replace_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.replace_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -replace_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.replace_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_namespaced_persistent_volume_claim -delete_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_resource_quota -delete_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_config_map_for_all_namespaces -list_config_map_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_config_map_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_deployment_scale -patch_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_service -replace_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_persistent_volume_claim_list -watch_namespaced_persistent_volume_claim_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_persistent_volume_claim_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_priority_level_configuration -read_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.read_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# connect_put_namespaced_service_proxy_with_path -connect_put_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_storage_class_list -watch_storage_class_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.watch_storage_v1_storage_class_list(_api::Kubernetes.StorageV1Api, args...; kwargs...) -watch_storage_class_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.watch_storage_v1beta1_storage_class_list(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# list_controller_revision_for_all_namespaces -list_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_controller_revision_for_all_namespaces(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# list_flow_schema -list_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.list_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# create_cluster_role_binding -create_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -create_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1alpha1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -create_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_rbac_authorization_v1beta1_cluster_role_binding(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# watch_namespaced_deployment_list -watch_namespaced_deployment_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_deployment_list(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_deployment_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_deployment_list(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_deployment_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_deployment_list(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_deployment_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_deployment_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_service_status -replace_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_validating_webhook_configuration -patch_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.patch_admissionregistration_v1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -patch_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.patch_admissionregistration_v1beta1_validating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# patch_namespaced_endpoints -patch_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_pod_disruption_budget -watch_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.watch_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# watch_service_list_for_all_namespaces -watch_service_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_service_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_ingress -delete_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.delete_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# replace_priority_level_configuration -replace_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.replace_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# watch_node -watch_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_get_namespaced_service_proxy -connect_get_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_get_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespace_finalize -replace_namespace_finalize(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespace_finalize(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_daemon_set -list_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -list_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_namespace -patch_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_job -create_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.create_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# replace_flow_schema_status -replace_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.replace_flowcontrol_apiserver_v1alpha1_flow_schema_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# delete_namespaced_horizontal_pod_autoscaler -delete_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -delete_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -delete_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.delete_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# delete_collection_namespaced_stateful_set -delete_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.delete_apps_v1_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -delete_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta1_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -delete_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.delete_apps_v1beta2_collection_namespaced_stateful_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# watch_lease_list_for_all_namespaces -watch_lease_list_for_all_namespaces(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1_lease_list_for_all_namespaces(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -watch_lease_list_for_all_namespaces(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.watch_coordination_v1beta1_lease_list_for_all_namespaces(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# delete_namespaced_lease -delete_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.delete_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -delete_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.delete_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_config_map -delete_collection_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_config_map(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_endpoints -replace_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_endpoint_slice -delete_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.delete_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# watch_mutating_webhook_configuration -watch_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -watch_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# list_namespaced_ingress -list_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -list_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.list_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_namespaced_network_policy -read_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -read_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.read_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# patch_namespaced_deployment -patch_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# delete_namespaced_pod_template -delete_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_pod_template(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_pod_security_policy_list -watch_pod_security_policy_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_pod_security_policy_list(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_pod_security_policy_list(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.watch_policy_v1beta1_pod_security_policy_list(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# patch_namespaced_replication_controller -patch_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_runtime_class -replace_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.replace_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -replace_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.replace_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# create_storage_class -create_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.create_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -create_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.create_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# replace_c_s_i_driver -replace_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.replace_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# replace_mutating_webhook_configuration -replace_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.replace_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -replace_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.replace_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# watch_namespaced_deployment -watch_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.watch_apps_v1_namespaced_deployment(_api::Kubernetes.AppsV1Api, args...; kwargs...) -watch_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta1_namespaced_deployment(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -watch_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.watch_apps_v1beta2_namespaced_deployment(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -watch_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_namespaced_deployment(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_node -patch_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_deployment_scale -replace_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_deployment_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta1_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -replace_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_deployment_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_deployment_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# replace_namespaced_cron_job -replace_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.replace_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -replace_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.replace_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -replace_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.replace_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# list_c_s_i_driver -list_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.list_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# connect_post_namespaced_pod_portforward -connect_post_namespaced_pod_portforward(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_post_namespaced_pod_portforward(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_provisioner -delete_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.delete_karpenter_sh_v1alpha5_provisioner(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# list_namespaced_cron_job -list_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.list_batch_v1_namespaced_cron_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) -list_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.list_batch_v1beta1_namespaced_cron_job(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -list_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.list_batch_v2alpha1_namespaced_cron_job(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# list_namespaced_metric_value -list_namespaced_metric_value(_api::Kubernetes.CustomMetricsV1beta1Api, args...; kwargs...) = Kubernetes.list_custom_metrics_v1beta1_namespaced_metric_value(_api::Kubernetes.CustomMetricsV1beta1Api, args...; kwargs...) - -# watch_namespaced_role_list -watch_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_namespaced_role_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# read_storage_class -read_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.read_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -read_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.read_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_custom_resource_definition -watch_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.watch_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -watch_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# list_namespaced_pod_preset -list_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.list_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# create_self_subject_access_review -create_self_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) = Kubernetes.create_authorization_v1_self_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) -create_self_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_authorization_v1beta1_self_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) - -# delete_storage_class -delete_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_storage_class(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_storage_class(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# create_audit_sink -create_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.create_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# watch_namespaced_persistent_volume_claim -watch_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_custom_resource_definition -list_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) = Kubernetes.list_apiextensions_v1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1Api, args...; kwargs...) -list_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_apiextensions_v1beta1_custom_resource_definition(_api::Kubernetes.ApiextensionsV1beta1Api, args...; kwargs...) - -# replace_persistent_volume -replace_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_patch_namespaced_service_proxy_with_path -connect_patch_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_patch_namespaced_service_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_put_node_proxy -connect_put_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_service_for_all_namespaces -list_service_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_service_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# read_pod_security_policy -read_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.read_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -read_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.read_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_persistent_volume -delete_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_persistent_volume(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_c_s_i_node -patch_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.patch_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -patch_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.patch_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# create_namespaced_pod_eviction -create_namespaced_pod_eviction(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_pod_eviction(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_namespaced_persistent_volume_claim -delete_collection_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_service_status -patch_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_service_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# connect_head_namespaced_service_proxy -connect_head_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_head_namespaced_service_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_pod_preset -delete_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.delete_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# patch_namespaced_role -patch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -patch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -patch_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.patch_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# patch_namespaced_daemon_set -patch_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_daemon_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_daemon_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_daemon_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_role_for_all_namespaces -list_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_role_for_all_namespaces(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_event_for_all_namespaces -list_event_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_event_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) -list_event_for_all_namespaces(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.list_events_v1beta1_event_for_all_namespaces(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_event -delete_collection_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_collection_namespaced_event(_api::Kubernetes.CoreV1Api, args...; kwargs...) -delete_collection_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) = Kubernetes.delete_events_v1beta1_collection_namespaced_event(_api::Kubernetes.EventsV1beta1Api, args...; kwargs...) - -# list_namespaced_limit_range -list_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_namespaced_network_policy -delete_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.delete_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# create_flow_schema -create_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.create_flowcontrol_apiserver_v1alpha1_flow_schema(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# list_cluster_role -list_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_cluster_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_cluster_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_cluster_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_endpoints_for_all_namespaces -list_endpoints_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_endpoints_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_priority_class -replace_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.replace_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -replace_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.replace_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -replace_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.replace_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# list_metric_value -list_metric_value(_api::Kubernetes.CustomMetricsV1beta1Api, args...; kwargs...) = Kubernetes.list_custom_metrics_v1beta1_metric_value(_api::Kubernetes.CustomMetricsV1beta1Api, args...; kwargs...) - -# patch_certificate_signing_request -patch_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.patch_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# read_certificate_signing_request_status -read_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.read_certificates_v1beta1_certificate_signing_request_status(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# read_namespace_status -read_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespace_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_namespaced_endpoint_slice -list_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.list_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# read_mutating_webhook_configuration -read_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.read_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -read_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.read_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# delete_collection_c_s_i_node -delete_collection_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_collection_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_collection_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_collection_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# watch_runtime_class -watch_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.watch_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -watch_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.watch_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# list_component_status -list_component_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_component_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_persistent_volume_claim -replace_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_priority_level_configuration_status -patch_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_status(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# list_c_s_i_node -list_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.list_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -list_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.list_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# delete_collection_namespaced_ingress -delete_collection_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.delete_extensions_v1beta1_collection_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -delete_collection_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.delete_networking_v1beta1_collection_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# read_node_metrics -read_node_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) = Kubernetes.read_metrics_v1beta1_node_metrics(_api::Kubernetes.MetricsV1beta1Api, args...; kwargs...) - -# read_audit_sink -read_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.read_auditregistration_v1alpha1_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# create_mutating_webhook_configuration -create_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) = Kubernetes.create_admissionregistration_v1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1Api, args...; kwargs...) -create_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) = Kubernetes.create_admissionregistration_v1beta1_mutating_webhook_configuration(_api::Kubernetes.AdmissionregistrationV1beta1Api, args...; kwargs...) - -# read_a_p_i_service -read_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.read_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -read_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.read_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# list_node -list_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_node(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_replication_controller_dummy_scale -patch_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_replication_controller_dummy_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# watch_priority_level_configuration_list -watch_priority_level_configuration_list(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.watch_flowcontrol_apiserver_v1alpha1_priority_level_configuration_list(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# list_pod_template_for_all_namespaces -list_pod_template_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_pod_template_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_resource_quota_list -watch_namespaced_resource_quota_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_resource_quota_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_replica_set -create_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.create_apps_v1_namespaced_replica_set(_api::Kubernetes.AppsV1Api, args...; kwargs...) -create_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.create_apps_v1beta2_namespaced_replica_set(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -create_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.create_extensions_v1beta1_namespaced_replica_set(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# patch_namespaced_ingress -patch_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_ingress(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -patch_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) = Kubernetes.patch_networking_v1beta1_namespaced_ingress(_api::Kubernetes.NetworkingV1beta1Api, args...; kwargs...) - -# patch_namespaced_horizontal_pod_autoscaler_status -patch_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -patch_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -patch_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.patch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# list_namespaced_resource_quota -list_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_provisioner_status -patch_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.patch_karpenter_sh_v1alpha5_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# create_subject_access_review -create_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) = Kubernetes.create_authorization_v1_subject_access_review(_api::Kubernetes.AuthorizationV1Api, args...; kwargs...) -create_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.create_authorization_v1beta1_subject_access_review(_api::Kubernetes.AuthorizationV1beta1Api, args...; kwargs...) - -# patch_namespaced_deployment_status -patch_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_deployment_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta1_namespaced_deployment_status(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -patch_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_deployment_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_deployment_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# create_namespaced_service_account -create_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# list_runtime_class -list_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.list_node_v1alpha1_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -list_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.list_node_v1beta1_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# replace_volume_attachment -replace_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.replace_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -replace_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.replace_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -replace_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.replace_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# read_namespaced_limit_range -read_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_limit_range(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespace -replace_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespace(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_replication_controller_scale -replace_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_replication_controller_scale(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_a_p_i_service_list -watch_a_p_i_service_list(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.watch_apiregistration_v1_a_p_i_service_list(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -watch_a_p_i_service_list(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.watch_apiregistration_v1beta1_a_p_i_service_list(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# replace_namespaced_endpoint_slice -replace_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.replace_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# watch_namespaced_endpoint_slice -watch_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) = Kubernetes.watch_discovery_v1beta1_namespaced_endpoint_slice(_api::Kubernetes.DiscoveryV1beta1Api, args...; kwargs...) - -# create_priority_level_configuration -create_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.create_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# read_provisioner_status -read_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) = Kubernetes.read_karpenter_sh_v1alpha5_provisioner_status(_api::Kubernetes.KarpenterShV1alpha5Api, args...; kwargs...) - -# patch_priority_class -patch_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) = Kubernetes.patch_scheduling_v1_priority_class(_api::Kubernetes.SchedulingV1Api, args...; kwargs...) -patch_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) = Kubernetes.patch_scheduling_v1alpha1_priority_class(_api::Kubernetes.SchedulingV1alpha1Api, args...; kwargs...) -patch_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) = Kubernetes.patch_scheduling_v1beta1_priority_class(_api::Kubernetes.SchedulingV1beta1Api, args...; kwargs...) - -# connect_options_node_proxy -connect_options_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_options_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_daemon_set_status -replace_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# read_namespaced_endpoints -read_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.read_core_v1_namespaced_endpoints(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_namespaced_pod_preset -create_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) = Kubernetes.create_settings_v1alpha1_namespaced_pod_preset(_api::Kubernetes.SettingsV1alpha1Api, args...; kwargs...) - -# patch_priority_level_configuration -patch_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) = Kubernetes.patch_flowcontrol_apiserver_v1alpha1_priority_level_configuration(_api::Kubernetes.FlowcontrolApiserverV1alpha1Api, args...; kwargs...) - -# watch_pod_template_list_for_all_namespaces -watch_pod_template_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_pod_template_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_certificate_signing_request -watch_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.watch_certificates_v1beta1_certificate_signing_request(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# replace_namespaced_replica_set_scale -replace_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.replace_apps_v1_namespaced_replica_set_scale(_api::Kubernetes.AppsV1Api, args...; kwargs...) -replace_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.replace_apps_v1beta2_namespaced_replica_set_scale(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -replace_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.replace_extensions_v1beta1_namespaced_replica_set_scale(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# create_namespaced_binding -create_namespaced_binding(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.create_core_v1_namespaced_binding(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_collection_audit_sink -delete_collection_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) = Kubernetes.delete_auditregistration_v1alpha1_collection_audit_sink(_api::Kubernetes.AuditregistrationV1alpha1Api, args...; kwargs...) - -# delete_namespaced_pod_disruption_budget -delete_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.delete_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# read_volume_attachment_status -read_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.read_storage_v1_volume_attachment_status(_api::Kubernetes.StorageV1Api, args...; kwargs...) - -# connect_delete_node_proxy -connect_delete_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_delete_node_proxy(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_role_binding_list -watch_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -watch_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1alpha1_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -watch_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.watch_rbac_authorization_v1beta1_namespaced_role_binding_list(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# list_namespaced_role -list_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1Api, args...; kwargs...) -list_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1alpha1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1alpha1Api, args...; kwargs...) -list_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) = Kubernetes.list_rbac_authorization_v1beta1_namespaced_role(_api::Kubernetes.RbacAuthorizationV1beta1Api, args...; kwargs...) - -# delete_collection_c_s_i_driver -delete_collection_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_collection_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# patch_c_s_i_driver -patch_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.patch_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# read_c_s_i_driver -read_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.read_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# patch_namespaced_service -patch_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_service(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_a_p_i_service -replace_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) = Kubernetes.replace_apiregistration_v1_a_p_i_service(_api::Kubernetes.ApiregistrationV1Api, args...; kwargs...) -replace_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) = Kubernetes.replace_apiregistration_v1beta1_a_p_i_service(_api::Kubernetes.ApiregistrationV1beta1Api, args...; kwargs...) - -# patch_namespaced_replication_controller_status -patch_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_replication_controller_status(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_horizontal_pod_autoscaler_status -replace_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -replace_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -replace_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.replace_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_status(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# replace_namespaced_job -replace_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.replace_batch_v1_namespaced_job(_api::Kubernetes.BatchV1Api, args...; kwargs...) - -# watch_namespaced_pod -watch_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_persistent_volume_list -watch_persistent_volume_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_persistent_volume_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_service_account_list_for_all_namespaces -watch_service_account_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_service_account_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_certificate_signing_request_approval -replace_certificate_signing_request_approval(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) = Kubernetes.replace_certificates_v1beta1_certificate_signing_request_approval(_api::Kubernetes.CertificatesV1beta1Api, args...; kwargs...) - -# watch_pod_security_policy -watch_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.watch_extensions_v1beta1_pod_security_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -watch_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.watch_policy_v1beta1_pod_security_policy(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# delete_collection_runtime_class -delete_collection_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) = Kubernetes.delete_node_v1alpha1_collection_runtime_class(_api::Kubernetes.NodeV1alpha1Api, args...; kwargs...) -delete_collection_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) = Kubernetes.delete_node_v1beta1_collection_runtime_class(_api::Kubernetes.NodeV1beta1Api, args...; kwargs...) - -# read_namespaced_pod_disruption_budget -read_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.read_policy_v1beta1_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# watch_namespaced_replication_controller_list -watch_namespaced_replication_controller_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_replication_controller_list(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_horizontal_pod_autoscaler_list -watch_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v1_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV1Api, args...; kwargs...) -watch_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta1_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV2beta1Api, args...; kwargs...) -watch_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) = Kubernetes.watch_autoscaling_v2beta2_namespaced_horizontal_pod_autoscaler_list(_api::Kubernetes.AutoscalingV2beta2Api, args...; kwargs...) - -# delete_namespaced_pod -delete_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.delete_core_v1_namespaced_pod(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_namespaced_replication_controller -watch_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_namespaced_replication_controller(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_resource_quota -patch_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.patch_core_v1_namespaced_resource_quota(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# patch_namespaced_daemon_set_status -patch_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.patch_apps_v1_namespaced_daemon_set_status(_api::Kubernetes.AppsV1Api, args...; kwargs...) -patch_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.patch_apps_v1beta2_namespaced_daemon_set_status(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) -patch_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.patch_extensions_v1beta1_namespaced_daemon_set_status(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) - -# list_namespaced_network_policy -list_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) = Kubernetes.list_extensions_v1beta1_namespaced_network_policy(_api::Kubernetes.ExtensionsV1beta1Api, args...; kwargs...) -list_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) = Kubernetes.list_networking_v1_namespaced_network_policy(_api::Kubernetes.NetworkingV1Api, args...; kwargs...) - -# watch_persistent_volume_claim_list_for_all_namespaces -watch_persistent_volume_claim_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.watch_core_v1_persistent_volume_claim_list_for_all_namespaces(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# delete_c_s_i_node -delete_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.delete_storage_v1_c_s_i_node(_api::Kubernetes.StorageV1Api, args...; kwargs...) -delete_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.delete_storage_v1beta1_c_s_i_node(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# list_namespaced_persistent_volume_claim -list_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.list_core_v1_namespaced_persistent_volume_claim(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# create_c_s_i_driver -create_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.create_storage_v1beta1_c_s_i_driver(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) - -# list_namespaced_controller_revision -list_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) = Kubernetes.list_apps_v1_namespaced_controller_revision(_api::Kubernetes.AppsV1Api, args...; kwargs...) -list_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) = Kubernetes.list_apps_v1beta1_namespaced_controller_revision(_api::Kubernetes.AppsV1beta1Api, args...; kwargs...) -list_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) = Kubernetes.list_apps_v1beta2_namespaced_controller_revision(_api::Kubernetes.AppsV1beta2Api, args...; kwargs...) - -# connect_put_namespaced_pod_proxy_with_path -connect_put_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.connect_core_v1_put_namespaced_pod_proxy_with_path(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# replace_namespaced_service_account -replace_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) = Kubernetes.replace_core_v1_namespaced_service_account(_api::Kubernetes.CoreV1Api, args...; kwargs...) - -# watch_cron_job_list_for_all_namespaces -watch_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) = Kubernetes.watch_batch_v1_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV1Api, args...; kwargs...) -watch_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) = Kubernetes.watch_batch_v1beta1_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV1beta1Api, args...; kwargs...) -watch_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) = Kubernetes.watch_batch_v2alpha1_cron_job_list_for_all_namespaces(_api::Kubernetes.BatchV2alpha1Api, args...; kwargs...) - -# delete_collection_namespaced_pod_disruption_budget -delete_collection_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) = Kubernetes.delete_policy_v1beta1_collection_namespaced_pod_disruption_budget(_api::Kubernetes.PolicyV1beta1Api, args...; kwargs...) - -# read_namespaced_lease -read_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) = Kubernetes.read_coordination_v1_namespaced_lease(_api::Kubernetes.CoordinationV1Api, args...; kwargs...) -read_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) = Kubernetes.read_coordination_v1beta1_namespaced_lease(_api::Kubernetes.CoordinationV1beta1Api, args...; kwargs...) - -# read_volume_attachment -read_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) = Kubernetes.read_storage_v1_volume_attachment(_api::Kubernetes.StorageV1Api, args...; kwargs...) -read_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) = Kubernetes.read_storage_v1alpha1_volume_attachment(_api::Kubernetes.StorageV1alpha1Api, args...; kwargs...) -read_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) = Kubernetes.read_storage_v1beta1_volume_attachment(_api::Kubernetes.StorageV1beta1Api, args...; kwargs...) diff --git a/src/ApiImpl/generated/K8sApiextensionsK8sIoV1.jl b/src/ApiImpl/generated/K8sApiextensionsK8sIoV1.jl new file mode 100644 index 00000000..5c6959c1 --- /dev/null +++ b/src/ApiImpl/generated/K8sApiextensionsK8sIoV1.jl @@ -0,0 +1,3258 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sApiextensionsK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", retrieval = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition\":{\"description\":\"CustomResourceColumnDefinition specifies a column for server side printing.\",\"properties\":{\"description\":{\"description\":\"description is a human readable description of this column.\",\"type\":\"string\"},\"format\":{\"description\":\"format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.\",\"type\":\"string\"},\"jsonPath\":{\"default\":\"\",\"description\":\"jsonPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is a human readable name for the column.\",\"type\":\"string\"},\"priority\":{\"description\":\"priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0.\",\"format\":\"int32\",\"type\":\"integer\"},\"type\":{\"default\":\"\",\"description\":\"type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details.\",\"type\":\"string\"}},\"required\":[\"name\",\"type\",\"jsonPath\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion\":{\"description\":\"CustomResourceConversion describes how to convert different versions of a CR.\",\"properties\":{\"strategy\":{\"default\":\"\",\"description\":\"strategy specifies how custom resources are converted between versions. Allowed values are: - `\\\"None\\\"`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `\\\"Webhook\\\"`: API Server will call to an external webhook to do the conversion. Additional information\\n is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set.\",\"type\":\"string\"},\"webhook\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion\"}},\"required\":[\"strategy\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\":{\"description\":\"CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}]},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition\":{\"description\":\"CustomResourceDefinitionCondition contains details for the current condition of this pod.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message is a human-readable message indicating details about last transition.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.\",\"format\":\"int64\",\"type\":\"integer\"},\"reason\":{\"description\":\"reason is a unique, one-word, CamelCase reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status is the status of the condition. Can be True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type is the type of the condition. Types include Established, NamesAccepted and Terminating.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\":{\"description\":\"CustomResourceDefinitionList is a list of CustomResourceDefinition objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items list individual CustomResourceDefinition objects\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinitionList\",\"version\":\"v1\"}]},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames\":{\"description\":\"CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition\",\"properties\":{\"categories\":{\"description\":\"categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"kind\":{\"default\":\"\",\"description\":\"kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls.\",\"type\":\"string\"},\"listKind\":{\"description\":\"listKind is the serialized kind of the list for this resource. Defaults to \\\"`kind`List\\\".\",\"type\":\"string\"},\"plural\":{\"default\":\"\",\"description\":\"plural is the plural name of the resource to serve. The custom resources are served under `/apis///.../`. Must match the name of the CustomResourceDefinition (in the form `.`). Must be all lowercase.\",\"type\":\"string\"},\"shortNames\":{\"description\":\"shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get `. It must be all lowercase.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singular\":{\"description\":\"singular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`.\",\"type\":\"string\"}},\"required\":[\"plural\",\"kind\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec\":{\"description\":\"CustomResourceDefinitionSpec describes how a user wants their resource to appear\",\"properties\":{\"conversion\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion\"},\"group\":{\"default\":\"\",\"description\":\"group is the API group of the defined custom resource. The custom resources are served under `/apis//...`. Must match the name of the CustomResourceDefinition (in the form `.`).\",\"type\":\"string\"},\"names\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames\"},\"preserveUnknownFields\":{\"description\":\"preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#field-pruning for details.\",\"type\":\"boolean\"},\"scope\":{\"default\":\"\",\"description\":\"scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`.\",\"type\":\"string\"},\"versions\":{\"description\":\"versions is the list of all API versions of the defined custom resource. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is \\\"kube-like\\\", it will sort above non \\\"kube-like\\\" version strings, which are ordered lexicographically. \\\"Kube-like\\\" versions start with a \\\"v\\\", then are followed by a number (the major version), then optionally the string \\\"alpha\\\" or \\\"beta\\\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"group\",\"names\",\"scope\",\"versions\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus\":{\"description\":\"CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition\",\"properties\":{\"acceptedNames\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames\"},\"conditions\":{\"description\":\"conditions indicate state for particular aspects of a CustomResourceDefinition\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true},\"observedGeneration\":{\"description\":\"The generation observed by the CRD controller.\",\"format\":\"int64\",\"type\":\"integer\"},\"storedVersions\":{\"description\":\"storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion\":{\"description\":\"CustomResourceDefinitionVersion describes a version for CRD.\",\"properties\":{\"additionalPrinterColumns\":{\"description\":\"additionalPrinterColumns specifies additional columns returned in Table output. See https://kubernetes.io/docs/reference/using-api/api-concepts/#receiving-resources-as-tables for details. If no columns are specified, a single column displaying the age of the custom resource is used.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"deprecated\":{\"description\":\"deprecated indicates this version of the custom resource API is deprecated. When set to true, API requests to this version receive a warning header in the server response. Defaults to false.\",\"type\":\"boolean\"},\"deprecationWarning\":{\"description\":\"deprecationWarning overrides the default warning returned to API clients. May only be set when `deprecated` is true. The default warning indicates this version is deprecated and recommends use of the newest served version of equal or greater stability, if one exists.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the version name, e.g. “v1”, “v2beta1”, etc. The custom resources are served under this version at `/apis///...` if `served` is true.\",\"type\":\"string\"},\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation\"},\"selectableFields\":{\"description\":\"selectableFields specifies paths to fields that may be used as field selectors. A maximum of 8 selectable fields are allowed. See https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"served\":{\"default\":false,\"description\":\"served is a flag enabling/disabling this version from being served via REST APIs\",\"type\":\"boolean\"},\"storage\":{\"default\":false,\"description\":\"storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true.\",\"type\":\"boolean\"},\"subresources\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources\"}},\"required\":[\"name\",\"served\",\"storage\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale\":{\"description\":\"CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources.\",\"properties\":{\"labelSelectorPath\":{\"description\":\"labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string.\",\"type\":\"string\"},\"specReplicasPath\":{\"default\":\"\",\"description\":\"specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET.\",\"type\":\"string\"},\"statusReplicasPath\":{\"default\":\"\",\"description\":\"statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0.\",\"type\":\"string\"}},\"required\":[\"specReplicasPath\",\"statusReplicasPath\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus\":{\"description\":\"CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza\",\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources\":{\"description\":\"CustomResourceSubresources defines the status and scale subresources for CustomResources.\",\"properties\":{\"scale\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus\"}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation\":{\"description\":\"CustomResourceValidation is a list of validation methods for CustomResources.\",\"properties\":{\"openAPIV3Schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation\":{\"description\":\"ExternalDocumentation allows referencing an external resource for extended documentation.\",\"properties\":{\"description\":{\"type\":\"string\"},\"url\":{\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON\":{\"description\":\"JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil.\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\":{\"description\":\"JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/).\",\"properties\":{\"\$ref\":{\"type\":\"string\"},\"\$schema\":{\"type\":\"string\"},\"additionalItems\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool\"},\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool\"},\"allOf\":{\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"anyOf\":{\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"default\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON\"},\"definitions\":{\"additionalProperties\":{\"allOf\":[{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"}],\"default\":{}},\"type\":\"object\"},\"dependencies\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray\"},\"type\":\"object\"},\"description\":{\"type\":\"string\"},\"enum\":{\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"example\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON\"},\"exclusiveMaximum\":{\"type\":\"boolean\"},\"exclusiveMinimum\":{\"type\":\"boolean\"},\"externalDocs\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation\"},\"format\":{\"description\":\"format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated:\\n\\n- bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}\$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}\$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}\$ - isbn: an ISBN10 or ISBN13 number string like \\\"0321751043\\\" or \\\"978-0321751041\\\" - isbn10: an ISBN10 number string like \\\"0321751043\\\" - isbn13: an ISBN13 number string like \\\"978-0321751041\\\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\\\\\\\d{3})\\\\\\\\d{11})\$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\\\\\\\d{3}[- ]?\\\\\\\\d{2}[- ]?\\\\\\\\d{4}\$ - hexcolor: an hexadecimal color code like \\\"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\$ - rgbcolor: an RGB color code like rgb like \\\"rgb(255,255,2559\\\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \\\"2006-01-02\\\" as defined by full-date in RFC3339 - duration: a duration string like \\\"22 ns\\\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \\\"2014-12-15T19:30:20.000Z\\\" as defined by date-time in RFC3339.\",\"type\":\"string\"},\"id\":{\"type\":\"string\"},\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray\"},\"maxItems\":{\"format\":\"int64\",\"type\":\"integer\"},\"maxLength\":{\"format\":\"int64\",\"type\":\"integer\"},\"maxProperties\":{\"format\":\"int64\",\"type\":\"integer\"},\"maximum\":{\"format\":\"double\",\"type\":\"number\"},\"minItems\":{\"format\":\"int64\",\"type\":\"integer\"},\"minLength\":{\"format\":\"int64\",\"type\":\"integer\"},\"minProperties\":{\"format\":\"int64\",\"type\":\"integer\"},\"minimum\":{\"format\":\"double\",\"type\":\"number\"},\"multipleOf\":{\"format\":\"double\",\"type\":\"number\"},\"not\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"},\"nullable\":{\"type\":\"boolean\"},\"oneOf\":{\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pattern\":{\"type\":\"string\"},\"patternProperties\":{\"additionalProperties\":{\"allOf\":[{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"}],\"default\":{}},\"type\":\"object\"},\"properties\":{\"additionalProperties\":{\"allOf\":[{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps\"}],\"default\":{}},\"type\":\"object\"},\"required\":{\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"title\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"},\"uniqueItems\":{\"type\":\"boolean\"},\"x-kubernetes-embedded-resource\":{\"description\":\"x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata).\",\"type\":\"boolean\"},\"x-kubernetes-int-or-string\":{\"description\":\"x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns:\\n\\n1) anyOf:\\n - type: integer\\n - type: string\\n2) allOf:\\n - anyOf:\\n - type: integer\\n - type: string\\n - ... zero or more\",\"type\":\"boolean\"},\"x-kubernetes-list-map-keys\":{\"description\":\"x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map.\\n\\nThis tag MUST only be used on lists that have the \\\"x-kubernetes-list-type\\\" extension set to \\\"map\\\". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported).\\n\\nThe properties specified must either be required or have a default value, to ensure those properties are present for all list items.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"x-kubernetes-list-type\":{\"description\":\"x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values:\\n\\n1) `atomic`: the list is treated as a single entity, like a scalar.\\n Atomic lists will be entirely replaced when updated. This extension\\n may be used on any type of list (struct, scalar, ...).\\n2) `set`:\\n Sets are lists that must not have multiple items with the same value. Each\\n value must be a scalar, an object with x-kubernetes-map-type `atomic` or an\\n array with x-kubernetes-list-type `atomic`.\\n3) `map`:\\n These lists are like maps in that their elements have a non-index key\\n used to identify them. Order is preserved upon merge. The map tag\\n must only be used on a list with elements of type object.\\nDefaults to atomic for arrays.\",\"type\":\"string\"},\"x-kubernetes-map-type\":{\"description\":\"x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values:\\n\\n1) `granular`:\\n These maps are actual maps (key-value pairs) and each fields are independent\\n from each other (they can each be manipulated by separate actors). This is\\n the default behaviour for all maps.\\n2) `atomic`: the list is treated as a single entity, like a scalar.\\n Atomic maps will be entirely replaced when updated.\",\"type\":\"string\"},\"x-kubernetes-preserve-unknown-fields\":{\"description\":\"x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden.\",\"type\":\"boolean\"},\"x-kubernetes-validations\":{\"description\":\"x-kubernetes-validations describes a list of validation rules written in the CEL expression language.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"rule\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"rule\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray\":{\"description\":\"JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes.\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool\":{\"description\":\"JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property.\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray\":{\"description\":\"JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array.\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField\":{\"description\":\"SelectableField specifies the JSON path of a field that may be used with field selectors.\",\"properties\":{\"jsonPath\":{\"default\":\"\",\"description\":\"jsonPath is a simple JSON path which is evaluated against each custom resource to produce a field selector value. Only JSON paths without the array notation are allowed. Must point to a field of type string, boolean or integer. Types with enum values and strings with formats are allowed. If jsonPath refers to absent field in a resource, the jsonPath evaluates to an empty string. Must not point to metdata fields. Required.\",\"type\":\"string\"}},\"required\":[\"jsonPath\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference\":{\"description\":\"ServiceReference holds a reference to Service.legacy.k8s.io\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name is the name of the service. Required\",\"type\":\"string\"},\"namespace\":{\"default\":\"\",\"description\":\"namespace is the namespace of the service. Required\",\"type\":\"string\"},\"path\":{\"description\":\"path is an optional URL path at which the webhook will be contacted.\",\"type\":\"string\"},\"port\":{\"description\":\"port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"namespace\",\"name\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule\":{\"description\":\"ValidationRule describes a validation rule written in the CEL expression language.\",\"properties\":{\"fieldPath\":{\"description\":\"fieldPath represents the field path returned when the validation fails. It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field. e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo` If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList` It does not support list numeric index. It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info. Numeric index of array is not supported. For field name which contains special characters, use `['specialName']` to refer the field name. e.g. for attribute `foo.34\$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34\$']`\",\"type\":\"string\"},\"message\":{\"description\":\"Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is \\\"failed rule: {Rule}\\\". e.g. \\\"must be a URL with the host matching spec.host\\\"\",\"type\":\"string\"},\"messageExpression\":{\"description\":\"MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails. Since messageExpression is used as a failure message, it must evaluate to a string. If both message and messageExpression are present on a rule, then messageExpression will be used if validation fails. If messageExpression results in a runtime error, the runtime error is logged, and the validation failure message is produced as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged. messageExpression has access to all the same variables as the rule; the only difference is the return type. Example: \\\"x must be less than max (\\\"+string(self.max)+\\\")\\\"\",\"type\":\"string\"},\"optionalOldSelf\":{\"description\":\"optionalOldSelf is used to opt a transition rule into evaluation even when the object is first created, or if the old object is missing the value.\\n\\nWhen enabled `oldSelf` will be a CEL optional whose value will be `None` if there is no old value, or when the object is initially created.\\n\\nYou may check for presence of oldSelf using `oldSelf.hasValue()` and unwrap it after checking using `oldSelf.value()`. Check the CEL documentation for Optional types for more information: https://pkg.go.dev/github.com/google/cel-go/cel#OptionalTypes\\n\\nMay not be set unless `oldSelf` is used in `rule`.\",\"type\":\"boolean\"},\"reason\":{\"description\":\"reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule. The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule. The currently supported reasons are: \\\"FieldValueInvalid\\\", \\\"FieldValueForbidden\\\", \\\"FieldValueRequired\\\", \\\"FieldValueDuplicate\\\". If not set, default to use \\\"FieldValueInvalid\\\". All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid.\",\"type\":\"string\"},\"rule\":{\"default\":\"\",\"description\":\"Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {\\\"rule\\\": \\\"self.status.actual <= self.spec.maxDesired\\\"}\\n\\nIf the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {\\\"rule\\\": \\\"self.components['Widget'].priority < 10\\\"} - Rule scoped to a list of integers: {\\\"rule\\\": \\\"self.values.all(value, value >= 0 && value < 100)\\\"} - Rule scoped to a string value: {\\\"rule\\\": \\\"self.startsWith('kube')\\\"}\\n\\nThe `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.\\n\\nUnknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an \\\"unknown type\\\". An \\\"unknown type\\\" is recursively defined as:\\n - A schema with no type and x-kubernetes-preserve-unknown-fields set to true\\n - An array where the items schema is of an \\\"unknown type\\\"\\n - An object where the additionalProperties schema is of an \\\"unknown type\\\"\\n\\nOnly property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are:\\n\\t \\\"true\\\", \\\"false\\\", \\\"null\\\", \\\"in\\\", \\\"as\\\", \\\"break\\\", \\\"const\\\", \\\"continue\\\", \\\"else\\\", \\\"for\\\", \\\"function\\\", \\\"if\\\",\\n\\t \\\"import\\\", \\\"let\\\", \\\"loop\\\", \\\"package\\\", \\\"namespace\\\", \\\"return\\\".\\nExamples:\\n - Rule accessing a property named \\\"namespace\\\": {\\\"rule\\\": \\\"self.__namespace__ > 0\\\"}\\n - Rule accessing a property named \\\"x-prop\\\": {\\\"rule\\\": \\\"self.x__dash__prop > 0\\\"}\\n - Rule accessing a property named \\\"redact__d\\\": {\\\"rule\\\": \\\"self.redact__underscores__d > 0\\\"}\\n\\nEquality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type:\\n - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and\\n non-intersecting elements in `Y` are appended, retaining their partial order.\\n - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values\\n are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with\\n non-intersecting keys are appended, retaining their partial order.\\n\\nIf `rule` makes use of the `oldSelf` variable it is implicitly a `transition rule`.\\n\\nBy default, the `oldSelf` variable is the same type as `self`. When `optionalOldSelf` is true, the `oldSelf` variable is a CEL optional\\n variable whose value() is the same type as `self`.\\nSee the documentation for the `optionalOldSelf` field for details.\\n\\nTransition rules by default are applied only on UPDATE requests and are skipped if an old value could not be found. You can opt a transition rule into unconditional evaluation by setting `optionalOldSelf` to true.\",\"type\":\"string\"}},\"required\":[\"rule\"],\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig\":{\"description\":\"WebhookClientConfig contains the information to make a TLS connection with the webhook.\",\"properties\":{\"caBundle\":{\"description\":\"caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used.\",\"format\":\"byte\",\"type\":\"string\"},\"service\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference\"},\"url\":{\"description\":\"url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified.\\n\\nThe `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.\\n\\nPlease note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.\\n\\nThe scheme must be \\\"https\\\"; the URL must begin with \\\"https://\\\".\\n\\nA path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.\\n\\nAttempting to use a user or basic auth e.g. \\\"user:password@\\\" is not allowed. Fragments (\\\"#...\\\") and query parameters (\\\"?...\\\") are not allowed, either.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion\":{\"description\":\"WebhookConversion describes how to call a conversion webhook\",\"properties\":{\"clientConfig\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig\"},\"conversionReviewVersions\":{\"description\":\"conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"conversionReviewVersions\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/apiextensions.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getApiextensionsV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"]}},\"/apis/apiextensions.k8s.io/v1/customresourcedefinitions\":{\"delete\":{\"description\":\"delete collection of CustomResourceDefinition\",\"operationId\":\"deleteApiextensionsV1CollectionCustomResourceDefinition\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CustomResourceDefinition\",\"operationId\":\"listApiextensionsV1CustomResourceDefinition\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CustomResourceDefinition\",\"operationId\":\"createApiextensionsV1CustomResourceDefinition\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}}},\"/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}\":{\"delete\":{\"description\":\"delete a CustomResourceDefinition\",\"operationId\":\"deleteApiextensionsV1CustomResourceDefinition\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CustomResourceDefinition\",\"operationId\":\"readApiextensionsV1CustomResourceDefinition\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CustomResourceDefinition\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CustomResourceDefinition\",\"operationId\":\"patchApiextensionsV1CustomResourceDefinition\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CustomResourceDefinition\",\"operationId\":\"replaceApiextensionsV1CustomResourceDefinition\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}}},\"/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status\":{\"get\":{\"description\":\"read status of the specified CustomResourceDefinition\",\"operationId\":\"readApiextensionsV1CustomResourceDefinitionStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the CustomResourceDefinition\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified CustomResourceDefinition\",\"operationId\":\"patchApiextensionsV1CustomResourceDefinitionStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified CustomResourceDefinition\",\"operationId\":\"replaceApiextensionsV1CustomResourceDefinitionStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}}},\"/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions\":{\"get\":{\"description\":\"watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchApiextensionsV1CustomResourceDefinitionList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchApiextensionsV1CustomResourceDefinition\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-519e65c07121bf63277c.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiextensions_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiextensions.k8s.io\",\"kind\":\"CustomResourceDefinition\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CustomResourceDefinition\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +abstract type AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps end +abstract type AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions end +abstract type AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties end +abstract type AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition + description::Union{Absent,Nothing,String} = ABSENT + format::Union{Absent,Nothing,String} = ABSENT + jsonpath::String + name::String + priority::Union{Absent,Int32,Nothing} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition") + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_format = haskey(_openapi_object, "format") ? _decode(Union{Absent,Nothing,String}, _openapi_object["format"], _openapi_validate) : ABSENT + _openapi_field_jsonpath = _decode(String, _required(_openapi_object, "jsonPath", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition"), _openapi_validate) + _openapi_field_priority = haskey(_openapi_object, "priority") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["priority"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("description","format","jsonPath","name","priority","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition(; description = _openapi_field_description, format = _openapi_field_format, jsonpath = _openapi_field_jsonpath, name = _openapi_field_name, priority = _openapi_field_priority, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.format isa Absent || (_openapi_output["format"] = _encode(_openapi_value.format)) + _openapi_value.jsonpath isa Absent || (_openapi_output["jsonPath"] = _encode(_openapi_value.jsonpath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.priority isa Absent || (_openapi_output["priority"] = _encode(_openapi_value.priority)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition) + _openapi_output = Pair{String,Any}[] + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.format isa Absent || push!(_openapi_output, "format" => _openapi_value.format) + _openapi_value.jsonpath isa Absent || push!(_openapi_output, "jsonPath" => _openapi_value.jsonpath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.priority isa Absent || push!(_openapi_output, "priority" => _openapi_value.priority) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference + name::String + namespace::String + path::Union{Absent,Nothing,String} = ABSENT + port::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference"), _openapi_validate) + _openapi_field_namespace = _decode(String, _required(_openapi_object, "namespace", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_port = haskey(_openapi_object, "port") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["port"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","namespace","path","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference(; name = _openapi_field_name, namespace = _openapi_field_namespace, path = _openapi_field_path, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig + cabundle::Union{Absent,Nothing,Vector{UInt8}} = ABSENT + service::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference,Nothing} = ABSENT + url::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig") + _openapi_field_cabundle = haskey(_openapi_object, "caBundle") ? _decode(Union{Absent,Nothing,Vector{UInt8}}, _openapi_object["caBundle"], _openapi_validate) : ABSENT + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ServiceReference,Nothing}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_field_url = haskey(_openapi_object, "url") ? _decode(Union{Absent,Nothing,String}, _openapi_object["url"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("caBundle","service","url") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig(; cabundle = _openapi_field_cabundle, service = _openapi_field_service, url = _openapi_field_url, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cabundle isa Absent || (_openapi_output["caBundle"] = _encode(_openapi_value.cabundle)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + _openapi_value.url isa Absent || (_openapi_output["url"] = _encode(_openapi_value.url)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.cabundle isa Absent || push!(_openapi_output, "caBundle" => _openapi_value.cabundle) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + _openapi_value.url isa Absent || push!(_openapi_output, "url" => _openapi_value.url) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion + clientconfig::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig,Nothing} = ABSENT + conversionreviewversions::Union{Nothing,Vector{String}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion") + _openapi_field_clientconfig = haskey(_openapi_object, "clientConfig") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookClientConfig,Nothing}, _openapi_object["clientConfig"], _openapi_validate) : ABSENT + _openapi_field_conversionreviewversions = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "conversionReviewVersions", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clientConfig","conversionReviewVersions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion(; clientconfig = _openapi_field_clientconfig, conversionreviewversions = _openapi_field_conversionreviewversions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clientconfig isa Absent || (_openapi_output["clientConfig"] = _encode(_openapi_value.clientconfig)) + _openapi_value.conversionreviewversions isa Absent || (_openapi_output["conversionReviewVersions"] = _encode(_openapi_value.conversionreviewversions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion) + _openapi_output = Pair{String,Any}[] + _openapi_value.clientconfig isa Absent || push!(_openapi_output, "clientConfig" => _openapi_value.clientconfig) + _openapi_value.conversionreviewversions isa Absent || push!(_openapi_output, "conversionReviewVersions" => _openapi_value.conversionreviewversions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion + strategy::String + webhook::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion") + _openapi_field_strategy = _decode(String, _required(_openapi_object, "strategy", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion"), _openapi_validate) + _openapi_field_webhook = haskey(_openapi_object, "webhook") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1WebhookConversion,Nothing}, _openapi_object["webhook"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("strategy","webhook") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion(; strategy = _openapi_field_strategy, webhook = _openapi_field_webhook, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.strategy isa Absent || (_openapi_output["strategy"] = _encode(_openapi_value.strategy)) + _openapi_value.webhook isa Absent || (_openapi_output["webhook"] = _encode(_openapi_value.webhook)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion) + _openapi_output = Pair{String,Any}[] + _openapi_value.strategy isa Absent || push!(_openapi_output, "strategy" => _openapi_value.strategy) + _openapi_value.webhook isa Absent || push!(_openapi_output, "webhook" => _openapi_value.webhook) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + kind::String + listkind::Union{Absent,Nothing,String} = ABSENT + plural::String + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singular::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames"), _openapi_validate) + _openapi_field_listkind = haskey(_openapi_object, "listKind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["listKind"], _openapi_validate) : ABSENT + _openapi_field_plural = _decode(String, _required(_openapi_object, "plural", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singular = haskey(_openapi_object, "singular") ? _decode(Union{Absent,Nothing,String}, _openapi_object["singular"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","kind","listKind","plural","shortNames","singular") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames(; categories = _openapi_field_categories, kind = _openapi_field_kind, listkind = _openapi_field_listkind, plural = _openapi_field_plural, shortnames = _openapi_field_shortnames, singular = _openapi_field_singular, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.listkind isa Absent || (_openapi_output["listKind"] = _encode(_openapi_value.listkind)) + _openapi_value.plural isa Absent || (_openapi_output["plural"] = _encode(_openapi_value.plural)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singular isa Absent || (_openapi_output["singular"] = _encode(_openapi_value.singular)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.listkind isa Absent || push!(_openapi_output, "listKind" => _openapi_value.listkind) + _openapi_value.plural isa Absent || push!(_openapi_output, "plural" => _openapi_value.plural) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singular isa Absent || push!(_openapi_output, "singular" => _openapi_value.singular) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/dependencies"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/dependencies"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation + description::Union{Absent,Nothing,String} = ABSENT + url::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation") + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_url = haskey(_openapi_object, "url") ? _decode(Union{Absent,Nothing,String}, _openapi_object["url"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("description","url") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation(; description = _openapi_field_description, url = _openapi_field_url, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.url isa Absent || (_openapi_output["url"] = _encode(_openapi_value.url)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation) + _openapi_output = Pair{String,Any}[] + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.url isa Absent || push!(_openapi_output, "url" => _openapi_value.url) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule + fieldpath::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + messageexpression::Union{Absent,Nothing,String} = ABSENT + optionaloldself::Union{Absent,Bool,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + rule::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule") + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_messageexpression = haskey(_openapi_object, "messageExpression") ? _decode(Union{Absent,Nothing,String}, _openapi_object["messageExpression"], _openapi_validate) : ABSENT + _openapi_field_optionaloldself = haskey(_openapi_object, "optionalOldSelf") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optionalOldSelf"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_rule = _decode(String, _required(_openapi_object, "rule", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fieldPath","message","messageExpression","optionalOldSelf","reason","rule") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule(; fieldpath = _openapi_field_fieldpath, message = _openapi_field_message, messageexpression = _openapi_field_messageexpression, optionaloldself = _openapi_field_optionaloldself, reason = _openapi_field_reason, rule = _openapi_field_rule, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.messageexpression isa Absent || (_openapi_output["messageExpression"] = _encode(_openapi_value.messageexpression)) + _openapi_value.optionaloldself isa Absent || (_openapi_output["optionalOldSelf"] = _encode(_openapi_value.optionaloldself)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.rule isa Absent || (_openapi_output["rule"] = _encode(_openapi_value.rule)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.messageexpression isa Absent || push!(_openapi_output, "messageExpression" => _openapi_value.messageexpression) + _openapi_value.optionaloldself isa Absent || push!(_openapi_output, "optionalOldSelf" => _openapi_value.optionaloldself) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.rule isa Absent || push!(_openapi_output, "rule" => _openapi_value.rule) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1 + ref::Union{Absent,Nothing,String} = ABSENT + schema::Union{Absent,Nothing,String} = ABSENT + additionalitems::Any = ABSENT + additionalproperties::Any = ABSENT + allof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + anyof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + default::Any = ABSENT + definitions::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing} = ABSENT + dependencies::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing} = ABSENT + description::Union{Absent,Nothing,String} = ABSENT + enum::Union{Absent,Union{Nothing,Vector{Any}}} = ABSENT + example::Any = ABSENT + exclusivemaximum::Union{Absent,Bool,Nothing} = ABSENT + exclusiveminimum::Union{Absent,Bool,Nothing} = ABSENT + externaldocs::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing} = ABSENT + format::Union{Absent,Nothing,String} = ABSENT + id::Union{Absent,Nothing,String} = ABSENT + items::Any = ABSENT + maxitems::Union{Absent,Int64,Nothing} = ABSENT + maxlength::Union{Absent,Int64,Nothing} = ABSENT + maxproperties::Union{Absent,Int64,Nothing} = ABSENT + maximum::Union{Absent,Float64,Nothing} = ABSENT + minitems::Union{Absent,Int64,Nothing} = ABSENT + minlength::Union{Absent,Int64,Nothing} = ABSENT + minproperties::Union{Absent,Int64,Nothing} = ABSENT + minimum::Union{Absent,Float64,Nothing} = ABSENT + multipleof::Union{Absent,Float64,Nothing} = ABSENT + not::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing} = ABSENT + nullable::Union{Absent,Bool,Nothing} = ABSENT + oneof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + pattern::Union{Absent,Nothing,String} = ABSENT + patternproperties::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing} = ABSENT + properties::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing} = ABSENT + required::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + title::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + uniqueitems::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_embedded_resource::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_int_or_string::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_list_map_keys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + x_kubernetes_list_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_map_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_preserve_unknown_fields::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_validations::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/properties/additionalProperties"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1") + _openapi_field_ref = haskey(_openapi_object, "\$ref") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$ref"], _openapi_validate) : ABSENT + _openapi_field_schema = haskey(_openapi_object, "\$schema") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$schema"], _openapi_validate) : ABSENT + _openapi_field_additionalitems = haskey(_openapi_object, "additionalItems") ? _decode(Any, _openapi_object["additionalItems"], _openapi_validate) : ABSENT + _openapi_field_additionalproperties = haskey(_openapi_object, "additionalProperties") ? _decode(Any, _openapi_object["additionalProperties"], _openapi_validate) : ABSENT + _openapi_field_allof = haskey(_openapi_object, "allOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["allOf"], _openapi_validate) : ABSENT + _openapi_field_anyof = haskey(_openapi_object, "anyOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["anyOf"], _openapi_validate) : ABSENT + _openapi_field_default = haskey(_openapi_object, "default") ? _decode(Any, _openapi_object["default"], _openapi_validate) : ABSENT + _openapi_field_definitions = haskey(_openapi_object, "definitions") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing}, _openapi_object["definitions"], _openapi_validate) : ABSENT + _openapi_field_dependencies = haskey(_openapi_object, "dependencies") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing}, _openapi_object["dependencies"], _openapi_validate) : ABSENT + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_enum = haskey(_openapi_object, "enum") ? _decode(Union{Absent,Union{Nothing,Vector{Any}}}, _openapi_object["enum"], _openapi_validate) : ABSENT + _openapi_field_example = haskey(_openapi_object, "example") ? _decode(Any, _openapi_object["example"], _openapi_validate) : ABSENT + _openapi_field_exclusivemaximum = haskey(_openapi_object, "exclusiveMaximum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMaximum"], _openapi_validate) : ABSENT + _openapi_field_exclusiveminimum = haskey(_openapi_object, "exclusiveMinimum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMinimum"], _openapi_validate) : ABSENT + _openapi_field_externaldocs = haskey(_openapi_object, "externalDocs") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing}, _openapi_object["externalDocs"], _openapi_validate) : ABSENT + _openapi_field_format = haskey(_openapi_object, "format") ? _decode(Union{Absent,Nothing,String}, _openapi_object["format"], _openapi_validate) : ABSENT + _openapi_field_id = haskey(_openapi_object, "id") ? _decode(Union{Absent,Nothing,String}, _openapi_object["id"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Any, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_maxitems = haskey(_openapi_object, "maxItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxItems"], _openapi_validate) : ABSENT + _openapi_field_maxlength = haskey(_openapi_object, "maxLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxLength"], _openapi_validate) : ABSENT + _openapi_field_maxproperties = haskey(_openapi_object, "maxProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxProperties"], _openapi_validate) : ABSENT + _openapi_field_maximum = haskey(_openapi_object, "maximum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["maximum"], _openapi_validate) : ABSENT + _openapi_field_minitems = haskey(_openapi_object, "minItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minItems"], _openapi_validate) : ABSENT + _openapi_field_minlength = haskey(_openapi_object, "minLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minLength"], _openapi_validate) : ABSENT + _openapi_field_minproperties = haskey(_openapi_object, "minProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minProperties"], _openapi_validate) : ABSENT + _openapi_field_minimum = haskey(_openapi_object, "minimum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["minimum"], _openapi_validate) : ABSENT + _openapi_field_multipleof = haskey(_openapi_object, "multipleOf") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["multipleOf"], _openapi_validate) : ABSENT + _openapi_field_not = haskey(_openapi_object, "not") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing}, _openapi_object["not"], _openapi_validate) : ABSENT + _openapi_field_nullable = haskey(_openapi_object, "nullable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["nullable"], _openapi_validate) : ABSENT + _openapi_field_oneof = haskey(_openapi_object, "oneOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["oneOf"], _openapi_validate) : ABSENT + _openapi_field_pattern = haskey(_openapi_object, "pattern") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pattern"], _openapi_validate) : ABSENT + _openapi_field_patternproperties = haskey(_openapi_object, "patternProperties") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing}, _openapi_object["patternProperties"], _openapi_validate) : ABSENT + _openapi_field_properties = haskey(_openapi_object, "properties") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing}, _openapi_object["properties"], _openapi_validate) : ABSENT + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_field_title = haskey(_openapi_object, "title") ? _decode(Union{Absent,Nothing,String}, _openapi_object["title"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_uniqueitems = haskey(_openapi_object, "uniqueItems") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["uniqueItems"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_embedded_resource = haskey(_openapi_object, "x-kubernetes-embedded-resource") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-embedded-resource"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_int_or_string = haskey(_openapi_object, "x-kubernetes-int-or-string") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-int-or-string"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_map_keys = haskey(_openapi_object, "x-kubernetes-list-map-keys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["x-kubernetes-list-map-keys"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_type = haskey(_openapi_object, "x-kubernetes-list-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-list-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_map_type = haskey(_openapi_object, "x-kubernetes-map-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-map-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_preserve_unknown_fields = haskey(_openapi_object, "x-kubernetes-preserve-unknown-fields") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-preserve-unknown-fields"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_validations = haskey(_openapi_object, "x-kubernetes-validations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}}, _openapi_object["x-kubernetes-validations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("\$ref","\$schema","additionalItems","additionalProperties","allOf","anyOf","default","definitions","dependencies","description","enum","example","exclusiveMaximum","exclusiveMinimum","externalDocs","format","id","items","maxItems","maxLength","maxProperties","maximum","minItems","minLength","minProperties","minimum","multipleOf","not","nullable","oneOf","pattern","patternProperties","properties","required","title","type","uniqueItems","x-kubernetes-embedded-resource","x-kubernetes-int-or-string","x-kubernetes-list-map-keys","x-kubernetes-list-type","x-kubernetes-map-type","x-kubernetes-preserve-unknown-fields","x-kubernetes-validations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1(; ref = _openapi_field_ref, schema = _openapi_field_schema, additionalitems = _openapi_field_additionalitems, additionalproperties = _openapi_field_additionalproperties, allof = _openapi_field_allof, anyof = _openapi_field_anyof, default = _openapi_field_default, definitions = _openapi_field_definitions, dependencies = _openapi_field_dependencies, description = _openapi_field_description, enum = _openapi_field_enum, example = _openapi_field_example, exclusivemaximum = _openapi_field_exclusivemaximum, exclusiveminimum = _openapi_field_exclusiveminimum, externaldocs = _openapi_field_externaldocs, format = _openapi_field_format, id = _openapi_field_id, items = _openapi_field_items, maxitems = _openapi_field_maxitems, maxlength = _openapi_field_maxlength, maxproperties = _openapi_field_maxproperties, maximum = _openapi_field_maximum, minitems = _openapi_field_minitems, minlength = _openapi_field_minlength, minproperties = _openapi_field_minproperties, minimum = _openapi_field_minimum, multipleof = _openapi_field_multipleof, not = _openapi_field_not, nullable = _openapi_field_nullable, oneof = _openapi_field_oneof, pattern = _openapi_field_pattern, patternproperties = _openapi_field_patternproperties, properties = _openapi_field_properties, required = _openapi_field_required, title = _openapi_field_title, type_ = _openapi_field_type_, uniqueitems = _openapi_field_uniqueitems, x_kubernetes_embedded_resource = _openapi_field_x_kubernetes_embedded_resource, x_kubernetes_int_or_string = _openapi_field_x_kubernetes_int_or_string, x_kubernetes_list_map_keys = _openapi_field_x_kubernetes_list_map_keys, x_kubernetes_list_type = _openapi_field_x_kubernetes_list_type, x_kubernetes_map_type = _openapi_field_x_kubernetes_map_type, x_kubernetes_preserve_unknown_fields = _openapi_field_x_kubernetes_preserve_unknown_fields, x_kubernetes_validations = _openapi_field_x_kubernetes_validations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ref isa Absent || (_openapi_output["\$ref"] = _encode(_openapi_value.ref)) + _openapi_value.schema isa Absent || (_openapi_output["\$schema"] = _encode(_openapi_value.schema)) + _openapi_value.additionalitems isa Absent || (_openapi_output["additionalItems"] = _encode(_openapi_value.additionalitems)) + _openapi_value.additionalproperties isa Absent || (_openapi_output["additionalProperties"] = _encode(_openapi_value.additionalproperties)) + _openapi_value.allof isa Absent || (_openapi_output["allOf"] = _encode(_openapi_value.allof)) + _openapi_value.anyof isa Absent || (_openapi_output["anyOf"] = _encode(_openapi_value.anyof)) + _openapi_value.default isa Absent || (_openapi_output["default"] = _encode(_openapi_value.default)) + _openapi_value.definitions isa Absent || (_openapi_output["definitions"] = _encode(_openapi_value.definitions)) + _openapi_value.dependencies isa Absent || (_openapi_output["dependencies"] = _encode(_openapi_value.dependencies)) + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.enum isa Absent || (_openapi_output["enum"] = _encode(_openapi_value.enum)) + _openapi_value.example isa Absent || (_openapi_output["example"] = _encode(_openapi_value.example)) + _openapi_value.exclusivemaximum isa Absent || (_openapi_output["exclusiveMaximum"] = _encode(_openapi_value.exclusivemaximum)) + _openapi_value.exclusiveminimum isa Absent || (_openapi_output["exclusiveMinimum"] = _encode(_openapi_value.exclusiveminimum)) + _openapi_value.externaldocs isa Absent || (_openapi_output["externalDocs"] = _encode(_openapi_value.externaldocs)) + _openapi_value.format isa Absent || (_openapi_output["format"] = _encode(_openapi_value.format)) + _openapi_value.id isa Absent || (_openapi_output["id"] = _encode(_openapi_value.id)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.maxitems isa Absent || (_openapi_output["maxItems"] = _encode(_openapi_value.maxitems)) + _openapi_value.maxlength isa Absent || (_openapi_output["maxLength"] = _encode(_openapi_value.maxlength)) + _openapi_value.maxproperties isa Absent || (_openapi_output["maxProperties"] = _encode(_openapi_value.maxproperties)) + _openapi_value.maximum isa Absent || (_openapi_output["maximum"] = _encode(_openapi_value.maximum)) + _openapi_value.minitems isa Absent || (_openapi_output["minItems"] = _encode(_openapi_value.minitems)) + _openapi_value.minlength isa Absent || (_openapi_output["minLength"] = _encode(_openapi_value.minlength)) + _openapi_value.minproperties isa Absent || (_openapi_output["minProperties"] = _encode(_openapi_value.minproperties)) + _openapi_value.minimum isa Absent || (_openapi_output["minimum"] = _encode(_openapi_value.minimum)) + _openapi_value.multipleof isa Absent || (_openapi_output["multipleOf"] = _encode(_openapi_value.multipleof)) + _openapi_value.not isa Absent || (_openapi_output["not"] = _encode(_openapi_value.not)) + _openapi_value.nullable isa Absent || (_openapi_output["nullable"] = _encode(_openapi_value.nullable)) + _openapi_value.oneof isa Absent || (_openapi_output["oneOf"] = _encode(_openapi_value.oneof)) + _openapi_value.pattern isa Absent || (_openapi_output["pattern"] = _encode(_openapi_value.pattern)) + _openapi_value.patternproperties isa Absent || (_openapi_output["patternProperties"] = _encode(_openapi_value.patternproperties)) + _openapi_value.properties isa Absent || (_openapi_output["properties"] = _encode(_openapi_value.properties)) + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + _openapi_value.title isa Absent || (_openapi_output["title"] = _encode(_openapi_value.title)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.uniqueitems isa Absent || (_openapi_output["uniqueItems"] = _encode(_openapi_value.uniqueitems)) + _openapi_value.x_kubernetes_embedded_resource isa Absent || (_openapi_output["x-kubernetes-embedded-resource"] = _encode(_openapi_value.x_kubernetes_embedded_resource)) + _openapi_value.x_kubernetes_int_or_string isa Absent || (_openapi_output["x-kubernetes-int-or-string"] = _encode(_openapi_value.x_kubernetes_int_or_string)) + _openapi_value.x_kubernetes_list_map_keys isa Absent || (_openapi_output["x-kubernetes-list-map-keys"] = _encode(_openapi_value.x_kubernetes_list_map_keys)) + _openapi_value.x_kubernetes_list_type isa Absent || (_openapi_output["x-kubernetes-list-type"] = _encode(_openapi_value.x_kubernetes_list_type)) + _openapi_value.x_kubernetes_map_type isa Absent || (_openapi_output["x-kubernetes-map-type"] = _encode(_openapi_value.x_kubernetes_map_type)) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || (_openapi_output["x-kubernetes-preserve-unknown-fields"] = _encode(_openapi_value.x_kubernetes_preserve_unknown_fields)) + _openapi_value.x_kubernetes_validations isa Absent || (_openapi_output["x-kubernetes-validations"] = _encode(_openapi_value.x_kubernetes_validations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/properties/additionalProperties"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1) + _openapi_output = Pair{String,Any}[] + _openapi_value.ref isa Absent || push!(_openapi_output, "\$ref" => _openapi_value.ref) + _openapi_value.schema isa Absent || push!(_openapi_output, "\$schema" => _openapi_value.schema) + _openapi_value.additionalitems isa Absent || push!(_openapi_output, "additionalItems" => _openapi_value.additionalitems) + _openapi_value.additionalproperties isa Absent || push!(_openapi_output, "additionalProperties" => _openapi_value.additionalproperties) + _openapi_value.allof isa Absent || push!(_openapi_output, "allOf" => _openapi_value.allof) + _openapi_value.anyof isa Absent || push!(_openapi_output, "anyOf" => _openapi_value.anyof) + _openapi_value.default isa Absent || push!(_openapi_output, "default" => _openapi_value.default) + _openapi_value.definitions isa Absent || push!(_openapi_output, "definitions" => _openapi_value.definitions) + _openapi_value.dependencies isa Absent || push!(_openapi_output, "dependencies" => _openapi_value.dependencies) + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.enum isa Absent || push!(_openapi_output, "enum" => _openapi_value.enum) + _openapi_value.example isa Absent || push!(_openapi_output, "example" => _openapi_value.example) + _openapi_value.exclusivemaximum isa Absent || push!(_openapi_output, "exclusiveMaximum" => _openapi_value.exclusivemaximum) + _openapi_value.exclusiveminimum isa Absent || push!(_openapi_output, "exclusiveMinimum" => _openapi_value.exclusiveminimum) + _openapi_value.externaldocs isa Absent || push!(_openapi_output, "externalDocs" => _openapi_value.externaldocs) + _openapi_value.format isa Absent || push!(_openapi_output, "format" => _openapi_value.format) + _openapi_value.id isa Absent || push!(_openapi_output, "id" => _openapi_value.id) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.maxitems isa Absent || push!(_openapi_output, "maxItems" => _openapi_value.maxitems) + _openapi_value.maxlength isa Absent || push!(_openapi_output, "maxLength" => _openapi_value.maxlength) + _openapi_value.maxproperties isa Absent || push!(_openapi_output, "maxProperties" => _openapi_value.maxproperties) + _openapi_value.maximum isa Absent || push!(_openapi_output, "maximum" => _openapi_value.maximum) + _openapi_value.minitems isa Absent || push!(_openapi_output, "minItems" => _openapi_value.minitems) + _openapi_value.minlength isa Absent || push!(_openapi_output, "minLength" => _openapi_value.minlength) + _openapi_value.minproperties isa Absent || push!(_openapi_output, "minProperties" => _openapi_value.minproperties) + _openapi_value.minimum isa Absent || push!(_openapi_output, "minimum" => _openapi_value.minimum) + _openapi_value.multipleof isa Absent || push!(_openapi_output, "multipleOf" => _openapi_value.multipleof) + _openapi_value.not isa Absent || push!(_openapi_output, "not" => _openapi_value.not) + _openapi_value.nullable isa Absent || push!(_openapi_output, "nullable" => _openapi_value.nullable) + _openapi_value.oneof isa Absent || push!(_openapi_output, "oneOf" => _openapi_value.oneof) + _openapi_value.pattern isa Absent || push!(_openapi_output, "pattern" => _openapi_value.pattern) + _openapi_value.patternproperties isa Absent || push!(_openapi_output, "patternProperties" => _openapi_value.patternproperties) + _openapi_value.properties isa Absent || push!(_openapi_output, "properties" => _openapi_value.properties) + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + _openapi_value.title isa Absent || push!(_openapi_output, "title" => _openapi_value.title) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.uniqueitems isa Absent || push!(_openapi_output, "uniqueItems" => _openapi_value.uniqueitems) + _openapi_value.x_kubernetes_embedded_resource isa Absent || push!(_openapi_output, "x-kubernetes-embedded-resource" => _openapi_value.x_kubernetes_embedded_resource) + _openapi_value.x_kubernetes_int_or_string isa Absent || push!(_openapi_output, "x-kubernetes-int-or-string" => _openapi_value.x_kubernetes_int_or_string) + _openapi_value.x_kubernetes_list_map_keys isa Absent || push!(_openapi_output, "x-kubernetes-list-map-keys" => _openapi_value.x_kubernetes_list_map_keys) + _openapi_value.x_kubernetes_list_type isa Absent || push!(_openapi_output, "x-kubernetes-list-type" => _openapi_value.x_kubernetes_list_type) + _openapi_value.x_kubernetes_map_type isa Absent || push!(_openapi_output, "x-kubernetes-map-type" => _openapi_value.x_kubernetes_map_type) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || push!(_openapi_output, "x-kubernetes-preserve-unknown-fields" => _openapi_value.x_kubernetes_preserve_unknown_fields) + _openapi_value.x_kubernetes_validations isa Absent || push!(_openapi_output, "x-kubernetes-validations" => _openapi_value.x_kubernetes_validations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties <: AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties + additional_properties::Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1} = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1}() +end +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties, value) +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties}, value, validate::Bool) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties, value, validate) +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/properties"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties") + _openapi_additional_properties = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1PropertiesAdditionalValue1, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/properties"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1 + ref::Union{Absent,Nothing,String} = ABSENT + schema::Union{Absent,Nothing,String} = ABSENT + additionalitems::Any = ABSENT + additionalproperties::Any = ABSENT + allof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + anyof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + default::Any = ABSENT + definitions::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing} = ABSENT + dependencies::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing} = ABSENT + description::Union{Absent,Nothing,String} = ABSENT + enum::Union{Absent,Union{Nothing,Vector{Any}}} = ABSENT + example::Any = ABSENT + exclusivemaximum::Union{Absent,Bool,Nothing} = ABSENT + exclusiveminimum::Union{Absent,Bool,Nothing} = ABSENT + externaldocs::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing} = ABSENT + format::Union{Absent,Nothing,String} = ABSENT + id::Union{Absent,Nothing,String} = ABSENT + items::Any = ABSENT + maxitems::Union{Absent,Int64,Nothing} = ABSENT + maxlength::Union{Absent,Int64,Nothing} = ABSENT + maxproperties::Union{Absent,Int64,Nothing} = ABSENT + maximum::Union{Absent,Float64,Nothing} = ABSENT + minitems::Union{Absent,Int64,Nothing} = ABSENT + minlength::Union{Absent,Int64,Nothing} = ABSENT + minproperties::Union{Absent,Int64,Nothing} = ABSENT + minimum::Union{Absent,Float64,Nothing} = ABSENT + multipleof::Union{Absent,Float64,Nothing} = ABSENT + not::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing} = ABSENT + nullable::Union{Absent,Bool,Nothing} = ABSENT + oneof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + pattern::Union{Absent,Nothing,String} = ABSENT + patternproperties::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing} = ABSENT + properties::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing} = ABSENT + required::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + title::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + uniqueitems::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_embedded_resource::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_int_or_string::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_list_map_keys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + x_kubernetes_list_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_map_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_preserve_unknown_fields::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_validations::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/patternProperties/additionalProperties"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1") + _openapi_field_ref = haskey(_openapi_object, "\$ref") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$ref"], _openapi_validate) : ABSENT + _openapi_field_schema = haskey(_openapi_object, "\$schema") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$schema"], _openapi_validate) : ABSENT + _openapi_field_additionalitems = haskey(_openapi_object, "additionalItems") ? _decode(Any, _openapi_object["additionalItems"], _openapi_validate) : ABSENT + _openapi_field_additionalproperties = haskey(_openapi_object, "additionalProperties") ? _decode(Any, _openapi_object["additionalProperties"], _openapi_validate) : ABSENT + _openapi_field_allof = haskey(_openapi_object, "allOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["allOf"], _openapi_validate) : ABSENT + _openapi_field_anyof = haskey(_openapi_object, "anyOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["anyOf"], _openapi_validate) : ABSENT + _openapi_field_default = haskey(_openapi_object, "default") ? _decode(Any, _openapi_object["default"], _openapi_validate) : ABSENT + _openapi_field_definitions = haskey(_openapi_object, "definitions") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing}, _openapi_object["definitions"], _openapi_validate) : ABSENT + _openapi_field_dependencies = haskey(_openapi_object, "dependencies") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing}, _openapi_object["dependencies"], _openapi_validate) : ABSENT + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_enum = haskey(_openapi_object, "enum") ? _decode(Union{Absent,Union{Nothing,Vector{Any}}}, _openapi_object["enum"], _openapi_validate) : ABSENT + _openapi_field_example = haskey(_openapi_object, "example") ? _decode(Any, _openapi_object["example"], _openapi_validate) : ABSENT + _openapi_field_exclusivemaximum = haskey(_openapi_object, "exclusiveMaximum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMaximum"], _openapi_validate) : ABSENT + _openapi_field_exclusiveminimum = haskey(_openapi_object, "exclusiveMinimum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMinimum"], _openapi_validate) : ABSENT + _openapi_field_externaldocs = haskey(_openapi_object, "externalDocs") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing}, _openapi_object["externalDocs"], _openapi_validate) : ABSENT + _openapi_field_format = haskey(_openapi_object, "format") ? _decode(Union{Absent,Nothing,String}, _openapi_object["format"], _openapi_validate) : ABSENT + _openapi_field_id = haskey(_openapi_object, "id") ? _decode(Union{Absent,Nothing,String}, _openapi_object["id"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Any, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_maxitems = haskey(_openapi_object, "maxItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxItems"], _openapi_validate) : ABSENT + _openapi_field_maxlength = haskey(_openapi_object, "maxLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxLength"], _openapi_validate) : ABSENT + _openapi_field_maxproperties = haskey(_openapi_object, "maxProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxProperties"], _openapi_validate) : ABSENT + _openapi_field_maximum = haskey(_openapi_object, "maximum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["maximum"], _openapi_validate) : ABSENT + _openapi_field_minitems = haskey(_openapi_object, "minItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minItems"], _openapi_validate) : ABSENT + _openapi_field_minlength = haskey(_openapi_object, "minLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minLength"], _openapi_validate) : ABSENT + _openapi_field_minproperties = haskey(_openapi_object, "minProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minProperties"], _openapi_validate) : ABSENT + _openapi_field_minimum = haskey(_openapi_object, "minimum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["minimum"], _openapi_validate) : ABSENT + _openapi_field_multipleof = haskey(_openapi_object, "multipleOf") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["multipleOf"], _openapi_validate) : ABSENT + _openapi_field_not = haskey(_openapi_object, "not") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing}, _openapi_object["not"], _openapi_validate) : ABSENT + _openapi_field_nullable = haskey(_openapi_object, "nullable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["nullable"], _openapi_validate) : ABSENT + _openapi_field_oneof = haskey(_openapi_object, "oneOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["oneOf"], _openapi_validate) : ABSENT + _openapi_field_pattern = haskey(_openapi_object, "pattern") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pattern"], _openapi_validate) : ABSENT + _openapi_field_patternproperties = haskey(_openapi_object, "patternProperties") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing}, _openapi_object["patternProperties"], _openapi_validate) : ABSENT + _openapi_field_properties = haskey(_openapi_object, "properties") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing}, _openapi_object["properties"], _openapi_validate) : ABSENT + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_field_title = haskey(_openapi_object, "title") ? _decode(Union{Absent,Nothing,String}, _openapi_object["title"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_uniqueitems = haskey(_openapi_object, "uniqueItems") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["uniqueItems"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_embedded_resource = haskey(_openapi_object, "x-kubernetes-embedded-resource") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-embedded-resource"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_int_or_string = haskey(_openapi_object, "x-kubernetes-int-or-string") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-int-or-string"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_map_keys = haskey(_openapi_object, "x-kubernetes-list-map-keys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["x-kubernetes-list-map-keys"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_type = haskey(_openapi_object, "x-kubernetes-list-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-list-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_map_type = haskey(_openapi_object, "x-kubernetes-map-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-map-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_preserve_unknown_fields = haskey(_openapi_object, "x-kubernetes-preserve-unknown-fields") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-preserve-unknown-fields"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_validations = haskey(_openapi_object, "x-kubernetes-validations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}}, _openapi_object["x-kubernetes-validations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("\$ref","\$schema","additionalItems","additionalProperties","allOf","anyOf","default","definitions","dependencies","description","enum","example","exclusiveMaximum","exclusiveMinimum","externalDocs","format","id","items","maxItems","maxLength","maxProperties","maximum","minItems","minLength","minProperties","minimum","multipleOf","not","nullable","oneOf","pattern","patternProperties","properties","required","title","type","uniqueItems","x-kubernetes-embedded-resource","x-kubernetes-int-or-string","x-kubernetes-list-map-keys","x-kubernetes-list-type","x-kubernetes-map-type","x-kubernetes-preserve-unknown-fields","x-kubernetes-validations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1(; ref = _openapi_field_ref, schema = _openapi_field_schema, additionalitems = _openapi_field_additionalitems, additionalproperties = _openapi_field_additionalproperties, allof = _openapi_field_allof, anyof = _openapi_field_anyof, default = _openapi_field_default, definitions = _openapi_field_definitions, dependencies = _openapi_field_dependencies, description = _openapi_field_description, enum = _openapi_field_enum, example = _openapi_field_example, exclusivemaximum = _openapi_field_exclusivemaximum, exclusiveminimum = _openapi_field_exclusiveminimum, externaldocs = _openapi_field_externaldocs, format = _openapi_field_format, id = _openapi_field_id, items = _openapi_field_items, maxitems = _openapi_field_maxitems, maxlength = _openapi_field_maxlength, maxproperties = _openapi_field_maxproperties, maximum = _openapi_field_maximum, minitems = _openapi_field_minitems, minlength = _openapi_field_minlength, minproperties = _openapi_field_minproperties, minimum = _openapi_field_minimum, multipleof = _openapi_field_multipleof, not = _openapi_field_not, nullable = _openapi_field_nullable, oneof = _openapi_field_oneof, pattern = _openapi_field_pattern, patternproperties = _openapi_field_patternproperties, properties = _openapi_field_properties, required = _openapi_field_required, title = _openapi_field_title, type_ = _openapi_field_type_, uniqueitems = _openapi_field_uniqueitems, x_kubernetes_embedded_resource = _openapi_field_x_kubernetes_embedded_resource, x_kubernetes_int_or_string = _openapi_field_x_kubernetes_int_or_string, x_kubernetes_list_map_keys = _openapi_field_x_kubernetes_list_map_keys, x_kubernetes_list_type = _openapi_field_x_kubernetes_list_type, x_kubernetes_map_type = _openapi_field_x_kubernetes_map_type, x_kubernetes_preserve_unknown_fields = _openapi_field_x_kubernetes_preserve_unknown_fields, x_kubernetes_validations = _openapi_field_x_kubernetes_validations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ref isa Absent || (_openapi_output["\$ref"] = _encode(_openapi_value.ref)) + _openapi_value.schema isa Absent || (_openapi_output["\$schema"] = _encode(_openapi_value.schema)) + _openapi_value.additionalitems isa Absent || (_openapi_output["additionalItems"] = _encode(_openapi_value.additionalitems)) + _openapi_value.additionalproperties isa Absent || (_openapi_output["additionalProperties"] = _encode(_openapi_value.additionalproperties)) + _openapi_value.allof isa Absent || (_openapi_output["allOf"] = _encode(_openapi_value.allof)) + _openapi_value.anyof isa Absent || (_openapi_output["anyOf"] = _encode(_openapi_value.anyof)) + _openapi_value.default isa Absent || (_openapi_output["default"] = _encode(_openapi_value.default)) + _openapi_value.definitions isa Absent || (_openapi_output["definitions"] = _encode(_openapi_value.definitions)) + _openapi_value.dependencies isa Absent || (_openapi_output["dependencies"] = _encode(_openapi_value.dependencies)) + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.enum isa Absent || (_openapi_output["enum"] = _encode(_openapi_value.enum)) + _openapi_value.example isa Absent || (_openapi_output["example"] = _encode(_openapi_value.example)) + _openapi_value.exclusivemaximum isa Absent || (_openapi_output["exclusiveMaximum"] = _encode(_openapi_value.exclusivemaximum)) + _openapi_value.exclusiveminimum isa Absent || (_openapi_output["exclusiveMinimum"] = _encode(_openapi_value.exclusiveminimum)) + _openapi_value.externaldocs isa Absent || (_openapi_output["externalDocs"] = _encode(_openapi_value.externaldocs)) + _openapi_value.format isa Absent || (_openapi_output["format"] = _encode(_openapi_value.format)) + _openapi_value.id isa Absent || (_openapi_output["id"] = _encode(_openapi_value.id)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.maxitems isa Absent || (_openapi_output["maxItems"] = _encode(_openapi_value.maxitems)) + _openapi_value.maxlength isa Absent || (_openapi_output["maxLength"] = _encode(_openapi_value.maxlength)) + _openapi_value.maxproperties isa Absent || (_openapi_output["maxProperties"] = _encode(_openapi_value.maxproperties)) + _openapi_value.maximum isa Absent || (_openapi_output["maximum"] = _encode(_openapi_value.maximum)) + _openapi_value.minitems isa Absent || (_openapi_output["minItems"] = _encode(_openapi_value.minitems)) + _openapi_value.minlength isa Absent || (_openapi_output["minLength"] = _encode(_openapi_value.minlength)) + _openapi_value.minproperties isa Absent || (_openapi_output["minProperties"] = _encode(_openapi_value.minproperties)) + _openapi_value.minimum isa Absent || (_openapi_output["minimum"] = _encode(_openapi_value.minimum)) + _openapi_value.multipleof isa Absent || (_openapi_output["multipleOf"] = _encode(_openapi_value.multipleof)) + _openapi_value.not isa Absent || (_openapi_output["not"] = _encode(_openapi_value.not)) + _openapi_value.nullable isa Absent || (_openapi_output["nullable"] = _encode(_openapi_value.nullable)) + _openapi_value.oneof isa Absent || (_openapi_output["oneOf"] = _encode(_openapi_value.oneof)) + _openapi_value.pattern isa Absent || (_openapi_output["pattern"] = _encode(_openapi_value.pattern)) + _openapi_value.patternproperties isa Absent || (_openapi_output["patternProperties"] = _encode(_openapi_value.patternproperties)) + _openapi_value.properties isa Absent || (_openapi_output["properties"] = _encode(_openapi_value.properties)) + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + _openapi_value.title isa Absent || (_openapi_output["title"] = _encode(_openapi_value.title)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.uniqueitems isa Absent || (_openapi_output["uniqueItems"] = _encode(_openapi_value.uniqueitems)) + _openapi_value.x_kubernetes_embedded_resource isa Absent || (_openapi_output["x-kubernetes-embedded-resource"] = _encode(_openapi_value.x_kubernetes_embedded_resource)) + _openapi_value.x_kubernetes_int_or_string isa Absent || (_openapi_output["x-kubernetes-int-or-string"] = _encode(_openapi_value.x_kubernetes_int_or_string)) + _openapi_value.x_kubernetes_list_map_keys isa Absent || (_openapi_output["x-kubernetes-list-map-keys"] = _encode(_openapi_value.x_kubernetes_list_map_keys)) + _openapi_value.x_kubernetes_list_type isa Absent || (_openapi_output["x-kubernetes-list-type"] = _encode(_openapi_value.x_kubernetes_list_type)) + _openapi_value.x_kubernetes_map_type isa Absent || (_openapi_output["x-kubernetes-map-type"] = _encode(_openapi_value.x_kubernetes_map_type)) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || (_openapi_output["x-kubernetes-preserve-unknown-fields"] = _encode(_openapi_value.x_kubernetes_preserve_unknown_fields)) + _openapi_value.x_kubernetes_validations isa Absent || (_openapi_output["x-kubernetes-validations"] = _encode(_openapi_value.x_kubernetes_validations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/patternProperties/additionalProperties"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1) + _openapi_output = Pair{String,Any}[] + _openapi_value.ref isa Absent || push!(_openapi_output, "\$ref" => _openapi_value.ref) + _openapi_value.schema isa Absent || push!(_openapi_output, "\$schema" => _openapi_value.schema) + _openapi_value.additionalitems isa Absent || push!(_openapi_output, "additionalItems" => _openapi_value.additionalitems) + _openapi_value.additionalproperties isa Absent || push!(_openapi_output, "additionalProperties" => _openapi_value.additionalproperties) + _openapi_value.allof isa Absent || push!(_openapi_output, "allOf" => _openapi_value.allof) + _openapi_value.anyof isa Absent || push!(_openapi_output, "anyOf" => _openapi_value.anyof) + _openapi_value.default isa Absent || push!(_openapi_output, "default" => _openapi_value.default) + _openapi_value.definitions isa Absent || push!(_openapi_output, "definitions" => _openapi_value.definitions) + _openapi_value.dependencies isa Absent || push!(_openapi_output, "dependencies" => _openapi_value.dependencies) + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.enum isa Absent || push!(_openapi_output, "enum" => _openapi_value.enum) + _openapi_value.example isa Absent || push!(_openapi_output, "example" => _openapi_value.example) + _openapi_value.exclusivemaximum isa Absent || push!(_openapi_output, "exclusiveMaximum" => _openapi_value.exclusivemaximum) + _openapi_value.exclusiveminimum isa Absent || push!(_openapi_output, "exclusiveMinimum" => _openapi_value.exclusiveminimum) + _openapi_value.externaldocs isa Absent || push!(_openapi_output, "externalDocs" => _openapi_value.externaldocs) + _openapi_value.format isa Absent || push!(_openapi_output, "format" => _openapi_value.format) + _openapi_value.id isa Absent || push!(_openapi_output, "id" => _openapi_value.id) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.maxitems isa Absent || push!(_openapi_output, "maxItems" => _openapi_value.maxitems) + _openapi_value.maxlength isa Absent || push!(_openapi_output, "maxLength" => _openapi_value.maxlength) + _openapi_value.maxproperties isa Absent || push!(_openapi_output, "maxProperties" => _openapi_value.maxproperties) + _openapi_value.maximum isa Absent || push!(_openapi_output, "maximum" => _openapi_value.maximum) + _openapi_value.minitems isa Absent || push!(_openapi_output, "minItems" => _openapi_value.minitems) + _openapi_value.minlength isa Absent || push!(_openapi_output, "minLength" => _openapi_value.minlength) + _openapi_value.minproperties isa Absent || push!(_openapi_output, "minProperties" => _openapi_value.minproperties) + _openapi_value.minimum isa Absent || push!(_openapi_output, "minimum" => _openapi_value.minimum) + _openapi_value.multipleof isa Absent || push!(_openapi_output, "multipleOf" => _openapi_value.multipleof) + _openapi_value.not isa Absent || push!(_openapi_output, "not" => _openapi_value.not) + _openapi_value.nullable isa Absent || push!(_openapi_output, "nullable" => _openapi_value.nullable) + _openapi_value.oneof isa Absent || push!(_openapi_output, "oneOf" => _openapi_value.oneof) + _openapi_value.pattern isa Absent || push!(_openapi_output, "pattern" => _openapi_value.pattern) + _openapi_value.patternproperties isa Absent || push!(_openapi_output, "patternProperties" => _openapi_value.patternproperties) + _openapi_value.properties isa Absent || push!(_openapi_output, "properties" => _openapi_value.properties) + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + _openapi_value.title isa Absent || push!(_openapi_output, "title" => _openapi_value.title) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.uniqueitems isa Absent || push!(_openapi_output, "uniqueItems" => _openapi_value.uniqueitems) + _openapi_value.x_kubernetes_embedded_resource isa Absent || push!(_openapi_output, "x-kubernetes-embedded-resource" => _openapi_value.x_kubernetes_embedded_resource) + _openapi_value.x_kubernetes_int_or_string isa Absent || push!(_openapi_output, "x-kubernetes-int-or-string" => _openapi_value.x_kubernetes_int_or_string) + _openapi_value.x_kubernetes_list_map_keys isa Absent || push!(_openapi_output, "x-kubernetes-list-map-keys" => _openapi_value.x_kubernetes_list_map_keys) + _openapi_value.x_kubernetes_list_type isa Absent || push!(_openapi_output, "x-kubernetes-list-type" => _openapi_value.x_kubernetes_list_type) + _openapi_value.x_kubernetes_map_type isa Absent || push!(_openapi_output, "x-kubernetes-map-type" => _openapi_value.x_kubernetes_map_type) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || push!(_openapi_output, "x-kubernetes-preserve-unknown-fields" => _openapi_value.x_kubernetes_preserve_unknown_fields) + _openapi_value.x_kubernetes_validations isa Absent || push!(_openapi_output, "x-kubernetes-validations" => _openapi_value.x_kubernetes_validations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties <: AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties + additional_properties::Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1} = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1}() +end +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties, value) +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties}, value, validate::Bool) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties, value, validate) +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/patternProperties"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties") + _openapi_additional_properties = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/patternProperties"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1 + ref::Union{Absent,Nothing,String} = ABSENT + schema::Union{Absent,Nothing,String} = ABSENT + additionalitems::Any = ABSENT + additionalproperties::Any = ABSENT + allof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + anyof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + default::Any = ABSENT + definitions::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing} = ABSENT + dependencies::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing} = ABSENT + description::Union{Absent,Nothing,String} = ABSENT + enum::Union{Absent,Union{Nothing,Vector{Any}}} = ABSENT + example::Any = ABSENT + exclusivemaximum::Union{Absent,Bool,Nothing} = ABSENT + exclusiveminimum::Union{Absent,Bool,Nothing} = ABSENT + externaldocs::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing} = ABSENT + format::Union{Absent,Nothing,String} = ABSENT + id::Union{Absent,Nothing,String} = ABSENT + items::Any = ABSENT + maxitems::Union{Absent,Int64,Nothing} = ABSENT + maxlength::Union{Absent,Int64,Nothing} = ABSENT + maxproperties::Union{Absent,Int64,Nothing} = ABSENT + maximum::Union{Absent,Float64,Nothing} = ABSENT + minitems::Union{Absent,Int64,Nothing} = ABSENT + minlength::Union{Absent,Int64,Nothing} = ABSENT + minproperties::Union{Absent,Int64,Nothing} = ABSENT + minimum::Union{Absent,Float64,Nothing} = ABSENT + multipleof::Union{Absent,Float64,Nothing} = ABSENT + not::Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing} = ABSENT + nullable::Union{Absent,Bool,Nothing} = ABSENT + oneof::Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + pattern::Union{Absent,Nothing,String} = ABSENT + patternproperties::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing} = ABSENT + properties::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing} = ABSENT + required::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + title::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + uniqueitems::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_embedded_resource::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_int_or_string::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_list_map_keys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + x_kubernetes_list_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_map_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_preserve_unknown_fields::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_validations::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/definitions/additionalProperties"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1") + _openapi_field_ref = haskey(_openapi_object, "\$ref") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$ref"], _openapi_validate) : ABSENT + _openapi_field_schema = haskey(_openapi_object, "\$schema") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$schema"], _openapi_validate) : ABSENT + _openapi_field_additionalitems = haskey(_openapi_object, "additionalItems") ? _decode(Any, _openapi_object["additionalItems"], _openapi_validate) : ABSENT + _openapi_field_additionalproperties = haskey(_openapi_object, "additionalProperties") ? _decode(Any, _openapi_object["additionalProperties"], _openapi_validate) : ABSENT + _openapi_field_allof = haskey(_openapi_object, "allOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["allOf"], _openapi_validate) : ABSENT + _openapi_field_anyof = haskey(_openapi_object, "anyOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["anyOf"], _openapi_validate) : ABSENT + _openapi_field_default = haskey(_openapi_object, "default") ? _decode(Any, _openapi_object["default"], _openapi_validate) : ABSENT + _openapi_field_definitions = haskey(_openapi_object, "definitions") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing}, _openapi_object["definitions"], _openapi_validate) : ABSENT + _openapi_field_dependencies = haskey(_openapi_object, "dependencies") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing}, _openapi_object["dependencies"], _openapi_validate) : ABSENT + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_enum = haskey(_openapi_object, "enum") ? _decode(Union{Absent,Union{Nothing,Vector{Any}}}, _openapi_object["enum"], _openapi_validate) : ABSENT + _openapi_field_example = haskey(_openapi_object, "example") ? _decode(Any, _openapi_object["example"], _openapi_validate) : ABSENT + _openapi_field_exclusivemaximum = haskey(_openapi_object, "exclusiveMaximum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMaximum"], _openapi_validate) : ABSENT + _openapi_field_exclusiveminimum = haskey(_openapi_object, "exclusiveMinimum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMinimum"], _openapi_validate) : ABSENT + _openapi_field_externaldocs = haskey(_openapi_object, "externalDocs") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing}, _openapi_object["externalDocs"], _openapi_validate) : ABSENT + _openapi_field_format = haskey(_openapi_object, "format") ? _decode(Union{Absent,Nothing,String}, _openapi_object["format"], _openapi_validate) : ABSENT + _openapi_field_id = haskey(_openapi_object, "id") ? _decode(Union{Absent,Nothing,String}, _openapi_object["id"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Any, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_maxitems = haskey(_openapi_object, "maxItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxItems"], _openapi_validate) : ABSENT + _openapi_field_maxlength = haskey(_openapi_object, "maxLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxLength"], _openapi_validate) : ABSENT + _openapi_field_maxproperties = haskey(_openapi_object, "maxProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxProperties"], _openapi_validate) : ABSENT + _openapi_field_maximum = haskey(_openapi_object, "maximum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["maximum"], _openapi_validate) : ABSENT + _openapi_field_minitems = haskey(_openapi_object, "minItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minItems"], _openapi_validate) : ABSENT + _openapi_field_minlength = haskey(_openapi_object, "minLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minLength"], _openapi_validate) : ABSENT + _openapi_field_minproperties = haskey(_openapi_object, "minProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minProperties"], _openapi_validate) : ABSENT + _openapi_field_minimum = haskey(_openapi_object, "minimum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["minimum"], _openapi_validate) : ABSENT + _openapi_field_multipleof = haskey(_openapi_object, "multipleOf") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["multipleOf"], _openapi_validate) : ABSENT + _openapi_field_not = haskey(_openapi_object, "not") ? _decode(Union{Absent,AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing}, _openapi_object["not"], _openapi_validate) : ABSENT + _openapi_field_nullable = haskey(_openapi_object, "nullable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["nullable"], _openapi_validate) : ABSENT + _openapi_field_oneof = haskey(_openapi_object, "oneOf") ? _decode(Union{Absent,Union{Nothing,Vector{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["oneOf"], _openapi_validate) : ABSENT + _openapi_field_pattern = haskey(_openapi_object, "pattern") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pattern"], _openapi_validate) : ABSENT + _openapi_field_patternproperties = haskey(_openapi_object, "patternProperties") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing}, _openapi_object["patternProperties"], _openapi_validate) : ABSENT + _openapi_field_properties = haskey(_openapi_object, "properties") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing}, _openapi_object["properties"], _openapi_validate) : ABSENT + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_field_title = haskey(_openapi_object, "title") ? _decode(Union{Absent,Nothing,String}, _openapi_object["title"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_uniqueitems = haskey(_openapi_object, "uniqueItems") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["uniqueItems"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_embedded_resource = haskey(_openapi_object, "x-kubernetes-embedded-resource") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-embedded-resource"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_int_or_string = haskey(_openapi_object, "x-kubernetes-int-or-string") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-int-or-string"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_map_keys = haskey(_openapi_object, "x-kubernetes-list-map-keys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["x-kubernetes-list-map-keys"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_type = haskey(_openapi_object, "x-kubernetes-list-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-list-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_map_type = haskey(_openapi_object, "x-kubernetes-map-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-map-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_preserve_unknown_fields = haskey(_openapi_object, "x-kubernetes-preserve-unknown-fields") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-preserve-unknown-fields"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_validations = haskey(_openapi_object, "x-kubernetes-validations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}}, _openapi_object["x-kubernetes-validations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("\$ref","\$schema","additionalItems","additionalProperties","allOf","anyOf","default","definitions","dependencies","description","enum","example","exclusiveMaximum","exclusiveMinimum","externalDocs","format","id","items","maxItems","maxLength","maxProperties","maximum","minItems","minLength","minProperties","minimum","multipleOf","not","nullable","oneOf","pattern","patternProperties","properties","required","title","type","uniqueItems","x-kubernetes-embedded-resource","x-kubernetes-int-or-string","x-kubernetes-list-map-keys","x-kubernetes-list-type","x-kubernetes-map-type","x-kubernetes-preserve-unknown-fields","x-kubernetes-validations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1(; ref = _openapi_field_ref, schema = _openapi_field_schema, additionalitems = _openapi_field_additionalitems, additionalproperties = _openapi_field_additionalproperties, allof = _openapi_field_allof, anyof = _openapi_field_anyof, default = _openapi_field_default, definitions = _openapi_field_definitions, dependencies = _openapi_field_dependencies, description = _openapi_field_description, enum = _openapi_field_enum, example = _openapi_field_example, exclusivemaximum = _openapi_field_exclusivemaximum, exclusiveminimum = _openapi_field_exclusiveminimum, externaldocs = _openapi_field_externaldocs, format = _openapi_field_format, id = _openapi_field_id, items = _openapi_field_items, maxitems = _openapi_field_maxitems, maxlength = _openapi_field_maxlength, maxproperties = _openapi_field_maxproperties, maximum = _openapi_field_maximum, minitems = _openapi_field_minitems, minlength = _openapi_field_minlength, minproperties = _openapi_field_minproperties, minimum = _openapi_field_minimum, multipleof = _openapi_field_multipleof, not = _openapi_field_not, nullable = _openapi_field_nullable, oneof = _openapi_field_oneof, pattern = _openapi_field_pattern, patternproperties = _openapi_field_patternproperties, properties = _openapi_field_properties, required = _openapi_field_required, title = _openapi_field_title, type_ = _openapi_field_type_, uniqueitems = _openapi_field_uniqueitems, x_kubernetes_embedded_resource = _openapi_field_x_kubernetes_embedded_resource, x_kubernetes_int_or_string = _openapi_field_x_kubernetes_int_or_string, x_kubernetes_list_map_keys = _openapi_field_x_kubernetes_list_map_keys, x_kubernetes_list_type = _openapi_field_x_kubernetes_list_type, x_kubernetes_map_type = _openapi_field_x_kubernetes_map_type, x_kubernetes_preserve_unknown_fields = _openapi_field_x_kubernetes_preserve_unknown_fields, x_kubernetes_validations = _openapi_field_x_kubernetes_validations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ref isa Absent || (_openapi_output["\$ref"] = _encode(_openapi_value.ref)) + _openapi_value.schema isa Absent || (_openapi_output["\$schema"] = _encode(_openapi_value.schema)) + _openapi_value.additionalitems isa Absent || (_openapi_output["additionalItems"] = _encode(_openapi_value.additionalitems)) + _openapi_value.additionalproperties isa Absent || (_openapi_output["additionalProperties"] = _encode(_openapi_value.additionalproperties)) + _openapi_value.allof isa Absent || (_openapi_output["allOf"] = _encode(_openapi_value.allof)) + _openapi_value.anyof isa Absent || (_openapi_output["anyOf"] = _encode(_openapi_value.anyof)) + _openapi_value.default isa Absent || (_openapi_output["default"] = _encode(_openapi_value.default)) + _openapi_value.definitions isa Absent || (_openapi_output["definitions"] = _encode(_openapi_value.definitions)) + _openapi_value.dependencies isa Absent || (_openapi_output["dependencies"] = _encode(_openapi_value.dependencies)) + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.enum isa Absent || (_openapi_output["enum"] = _encode(_openapi_value.enum)) + _openapi_value.example isa Absent || (_openapi_output["example"] = _encode(_openapi_value.example)) + _openapi_value.exclusivemaximum isa Absent || (_openapi_output["exclusiveMaximum"] = _encode(_openapi_value.exclusivemaximum)) + _openapi_value.exclusiveminimum isa Absent || (_openapi_output["exclusiveMinimum"] = _encode(_openapi_value.exclusiveminimum)) + _openapi_value.externaldocs isa Absent || (_openapi_output["externalDocs"] = _encode(_openapi_value.externaldocs)) + _openapi_value.format isa Absent || (_openapi_output["format"] = _encode(_openapi_value.format)) + _openapi_value.id isa Absent || (_openapi_output["id"] = _encode(_openapi_value.id)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.maxitems isa Absent || (_openapi_output["maxItems"] = _encode(_openapi_value.maxitems)) + _openapi_value.maxlength isa Absent || (_openapi_output["maxLength"] = _encode(_openapi_value.maxlength)) + _openapi_value.maxproperties isa Absent || (_openapi_output["maxProperties"] = _encode(_openapi_value.maxproperties)) + _openapi_value.maximum isa Absent || (_openapi_output["maximum"] = _encode(_openapi_value.maximum)) + _openapi_value.minitems isa Absent || (_openapi_output["minItems"] = _encode(_openapi_value.minitems)) + _openapi_value.minlength isa Absent || (_openapi_output["minLength"] = _encode(_openapi_value.minlength)) + _openapi_value.minproperties isa Absent || (_openapi_output["minProperties"] = _encode(_openapi_value.minproperties)) + _openapi_value.minimum isa Absent || (_openapi_output["minimum"] = _encode(_openapi_value.minimum)) + _openapi_value.multipleof isa Absent || (_openapi_output["multipleOf"] = _encode(_openapi_value.multipleof)) + _openapi_value.not isa Absent || (_openapi_output["not"] = _encode(_openapi_value.not)) + _openapi_value.nullable isa Absent || (_openapi_output["nullable"] = _encode(_openapi_value.nullable)) + _openapi_value.oneof isa Absent || (_openapi_output["oneOf"] = _encode(_openapi_value.oneof)) + _openapi_value.pattern isa Absent || (_openapi_output["pattern"] = _encode(_openapi_value.pattern)) + _openapi_value.patternproperties isa Absent || (_openapi_output["patternProperties"] = _encode(_openapi_value.patternproperties)) + _openapi_value.properties isa Absent || (_openapi_output["properties"] = _encode(_openapi_value.properties)) + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + _openapi_value.title isa Absent || (_openapi_output["title"] = _encode(_openapi_value.title)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.uniqueitems isa Absent || (_openapi_output["uniqueItems"] = _encode(_openapi_value.uniqueitems)) + _openapi_value.x_kubernetes_embedded_resource isa Absent || (_openapi_output["x-kubernetes-embedded-resource"] = _encode(_openapi_value.x_kubernetes_embedded_resource)) + _openapi_value.x_kubernetes_int_or_string isa Absent || (_openapi_output["x-kubernetes-int-or-string"] = _encode(_openapi_value.x_kubernetes_int_or_string)) + _openapi_value.x_kubernetes_list_map_keys isa Absent || (_openapi_output["x-kubernetes-list-map-keys"] = _encode(_openapi_value.x_kubernetes_list_map_keys)) + _openapi_value.x_kubernetes_list_type isa Absent || (_openapi_output["x-kubernetes-list-type"] = _encode(_openapi_value.x_kubernetes_list_type)) + _openapi_value.x_kubernetes_map_type isa Absent || (_openapi_output["x-kubernetes-map-type"] = _encode(_openapi_value.x_kubernetes_map_type)) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || (_openapi_output["x-kubernetes-preserve-unknown-fields"] = _encode(_openapi_value.x_kubernetes_preserve_unknown_fields)) + _openapi_value.x_kubernetes_validations isa Absent || (_openapi_output["x-kubernetes-validations"] = _encode(_openapi_value.x_kubernetes_validations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/definitions/additionalProperties"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1) + _openapi_output = Pair{String,Any}[] + _openapi_value.ref isa Absent || push!(_openapi_output, "\$ref" => _openapi_value.ref) + _openapi_value.schema isa Absent || push!(_openapi_output, "\$schema" => _openapi_value.schema) + _openapi_value.additionalitems isa Absent || push!(_openapi_output, "additionalItems" => _openapi_value.additionalitems) + _openapi_value.additionalproperties isa Absent || push!(_openapi_output, "additionalProperties" => _openapi_value.additionalproperties) + _openapi_value.allof isa Absent || push!(_openapi_output, "allOf" => _openapi_value.allof) + _openapi_value.anyof isa Absent || push!(_openapi_output, "anyOf" => _openapi_value.anyof) + _openapi_value.default isa Absent || push!(_openapi_output, "default" => _openapi_value.default) + _openapi_value.definitions isa Absent || push!(_openapi_output, "definitions" => _openapi_value.definitions) + _openapi_value.dependencies isa Absent || push!(_openapi_output, "dependencies" => _openapi_value.dependencies) + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.enum isa Absent || push!(_openapi_output, "enum" => _openapi_value.enum) + _openapi_value.example isa Absent || push!(_openapi_output, "example" => _openapi_value.example) + _openapi_value.exclusivemaximum isa Absent || push!(_openapi_output, "exclusiveMaximum" => _openapi_value.exclusivemaximum) + _openapi_value.exclusiveminimum isa Absent || push!(_openapi_output, "exclusiveMinimum" => _openapi_value.exclusiveminimum) + _openapi_value.externaldocs isa Absent || push!(_openapi_output, "externalDocs" => _openapi_value.externaldocs) + _openapi_value.format isa Absent || push!(_openapi_output, "format" => _openapi_value.format) + _openapi_value.id isa Absent || push!(_openapi_output, "id" => _openapi_value.id) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.maxitems isa Absent || push!(_openapi_output, "maxItems" => _openapi_value.maxitems) + _openapi_value.maxlength isa Absent || push!(_openapi_output, "maxLength" => _openapi_value.maxlength) + _openapi_value.maxproperties isa Absent || push!(_openapi_output, "maxProperties" => _openapi_value.maxproperties) + _openapi_value.maximum isa Absent || push!(_openapi_output, "maximum" => _openapi_value.maximum) + _openapi_value.minitems isa Absent || push!(_openapi_output, "minItems" => _openapi_value.minitems) + _openapi_value.minlength isa Absent || push!(_openapi_output, "minLength" => _openapi_value.minlength) + _openapi_value.minproperties isa Absent || push!(_openapi_output, "minProperties" => _openapi_value.minproperties) + _openapi_value.minimum isa Absent || push!(_openapi_output, "minimum" => _openapi_value.minimum) + _openapi_value.multipleof isa Absent || push!(_openapi_output, "multipleOf" => _openapi_value.multipleof) + _openapi_value.not isa Absent || push!(_openapi_output, "not" => _openapi_value.not) + _openapi_value.nullable isa Absent || push!(_openapi_output, "nullable" => _openapi_value.nullable) + _openapi_value.oneof isa Absent || push!(_openapi_output, "oneOf" => _openapi_value.oneof) + _openapi_value.pattern isa Absent || push!(_openapi_output, "pattern" => _openapi_value.pattern) + _openapi_value.patternproperties isa Absent || push!(_openapi_output, "patternProperties" => _openapi_value.patternproperties) + _openapi_value.properties isa Absent || push!(_openapi_output, "properties" => _openapi_value.properties) + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + _openapi_value.title isa Absent || push!(_openapi_output, "title" => _openapi_value.title) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.uniqueitems isa Absent || push!(_openapi_output, "uniqueItems" => _openapi_value.uniqueitems) + _openapi_value.x_kubernetes_embedded_resource isa Absent || push!(_openapi_output, "x-kubernetes-embedded-resource" => _openapi_value.x_kubernetes_embedded_resource) + _openapi_value.x_kubernetes_int_or_string isa Absent || push!(_openapi_output, "x-kubernetes-int-or-string" => _openapi_value.x_kubernetes_int_or_string) + _openapi_value.x_kubernetes_list_map_keys isa Absent || push!(_openapi_output, "x-kubernetes-list-map-keys" => _openapi_value.x_kubernetes_list_map_keys) + _openapi_value.x_kubernetes_list_type isa Absent || push!(_openapi_output, "x-kubernetes-list-type" => _openapi_value.x_kubernetes_list_type) + _openapi_value.x_kubernetes_map_type isa Absent || push!(_openapi_output, "x-kubernetes-map-type" => _openapi_value.x_kubernetes_map_type) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || push!(_openapi_output, "x-kubernetes-preserve-unknown-fields" => _openapi_value.x_kubernetes_preserve_unknown_fields) + _openapi_value.x_kubernetes_validations isa Absent || push!(_openapi_output, "x-kubernetes-validations" => _openapi_value.x_kubernetes_validations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions <: AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions + additional_properties::Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1} = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1}() +end +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions, value) +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions}, value, validate::Bool) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions, value, validate) +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/definitions"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions") + _openapi_additional_properties = Dict{String,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps/properties/definitions"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps <: AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps + ref::Union{Absent,Nothing,String} = ABSENT + schema::Union{Absent,Nothing,String} = ABSENT + additionalitems::Any = ABSENT + additionalproperties::Any = ABSENT + allof::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + anyof::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + default::Any = ABSENT + definitions::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing} = ABSENT + dependencies::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing} = ABSENT + description::Union{Absent,Nothing,String} = ABSENT + enum::Union{Absent,Union{Nothing,Vector{Any}}} = ABSENT + example::Any = ABSENT + exclusivemaximum::Union{Absent,Bool,Nothing} = ABSENT + exclusiveminimum::Union{Absent,Bool,Nothing} = ABSENT + externaldocs::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing} = ABSENT + format::Union{Absent,Nothing,String} = ABSENT + id::Union{Absent,Nothing,String} = ABSENT + items::Any = ABSENT + maxitems::Union{Absent,Int64,Nothing} = ABSENT + maxlength::Union{Absent,Int64,Nothing} = ABSENT + maxproperties::Union{Absent,Int64,Nothing} = ABSENT + maximum::Union{Absent,Float64,Nothing} = ABSENT + minitems::Union{Absent,Int64,Nothing} = ABSENT + minlength::Union{Absent,Int64,Nothing} = ABSENT + minproperties::Union{Absent,Int64,Nothing} = ABSENT + minimum::Union{Absent,Float64,Nothing} = ABSENT + multipleof::Union{Absent,Float64,Nothing} = ABSENT + not::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing} = ABSENT + nullable::Union{Absent,Bool,Nothing} = ABSENT + oneof::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}} = ABSENT + pattern::Union{Absent,Nothing,String} = ABSENT + patternproperties::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing} = ABSENT + properties::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing} = ABSENT + required::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + title::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + uniqueitems::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_embedded_resource::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_int_or_string::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_list_map_keys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + x_kubernetes_list_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_map_type::Union{Absent,Nothing,String} = ABSENT + x_kubernetes_preserve_unknown_fields::Union{Absent,Bool,Nothing} = ABSENT + x_kubernetes_validations::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, value) +_decode(::Type{AbstractIoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}, value, validate::Bool) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, value, validate) +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps") + _openapi_field_ref = haskey(_openapi_object, "\$ref") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$ref"], _openapi_validate) : ABSENT + _openapi_field_schema = haskey(_openapi_object, "\$schema") ? _decode(Union{Absent,Nothing,String}, _openapi_object["\$schema"], _openapi_validate) : ABSENT + _openapi_field_additionalitems = haskey(_openapi_object, "additionalItems") ? _decode(Any, _openapi_object["additionalItems"], _openapi_validate) : ABSENT + _openapi_field_additionalproperties = haskey(_openapi_object, "additionalProperties") ? _decode(Any, _openapi_object["additionalProperties"], _openapi_validate) : ABSENT + _openapi_field_allof = haskey(_openapi_object, "allOf") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["allOf"], _openapi_validate) : ABSENT + _openapi_field_anyof = haskey(_openapi_object, "anyOf") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["anyOf"], _openapi_validate) : ABSENT + _openapi_field_default = haskey(_openapi_object, "default") ? _decode(Any, _openapi_object["default"], _openapi_validate) : ABSENT + _openapi_field_definitions = haskey(_openapi_object, "definitions") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitions,Nothing}, _openapi_object["definitions"], _openapi_validate) : ABSENT + _openapi_field_dependencies = haskey(_openapi_object, "dependencies") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1Dependencies,Nothing}, _openapi_object["dependencies"], _openapi_validate) : ABSENT + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_enum = haskey(_openapi_object, "enum") ? _decode(Union{Absent,Union{Nothing,Vector{Any}}}, _openapi_object["enum"], _openapi_validate) : ABSENT + _openapi_field_example = haskey(_openapi_object, "example") ? _decode(Any, _openapi_object["example"], _openapi_validate) : ABSENT + _openapi_field_exclusivemaximum = haskey(_openapi_object, "exclusiveMaximum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMaximum"], _openapi_validate) : ABSENT + _openapi_field_exclusiveminimum = haskey(_openapi_object, "exclusiveMinimum") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["exclusiveMinimum"], _openapi_validate) : ABSENT + _openapi_field_externaldocs = haskey(_openapi_object, "externalDocs") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1ExternalDocumentation,Nothing}, _openapi_object["externalDocs"], _openapi_validate) : ABSENT + _openapi_field_format = haskey(_openapi_object, "format") ? _decode(Union{Absent,Nothing,String}, _openapi_object["format"], _openapi_validate) : ABSENT + _openapi_field_id = haskey(_openapi_object, "id") ? _decode(Union{Absent,Nothing,String}, _openapi_object["id"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Any, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_maxitems = haskey(_openapi_object, "maxItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxItems"], _openapi_validate) : ABSENT + _openapi_field_maxlength = haskey(_openapi_object, "maxLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxLength"], _openapi_validate) : ABSENT + _openapi_field_maxproperties = haskey(_openapi_object, "maxProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["maxProperties"], _openapi_validate) : ABSENT + _openapi_field_maximum = haskey(_openapi_object, "maximum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["maximum"], _openapi_validate) : ABSENT + _openapi_field_minitems = haskey(_openapi_object, "minItems") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minItems"], _openapi_validate) : ABSENT + _openapi_field_minlength = haskey(_openapi_object, "minLength") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minLength"], _openapi_validate) : ABSENT + _openapi_field_minproperties = haskey(_openapi_object, "minProperties") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["minProperties"], _openapi_validate) : ABSENT + _openapi_field_minimum = haskey(_openapi_object, "minimum") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["minimum"], _openapi_validate) : ABSENT + _openapi_field_multipleof = haskey(_openapi_object, "multipleOf") ? _decode(Union{Absent,Float64,Nothing}, _openapi_object["multipleOf"], _openapi_validate) : ABSENT + _openapi_field_not = haskey(_openapi_object, "not") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing}, _openapi_object["not"], _openapi_validate) : ABSENT + _openapi_field_nullable = haskey(_openapi_object, "nullable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["nullable"], _openapi_validate) : ABSENT + _openapi_field_oneof = haskey(_openapi_object, "oneOf") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps}}}, _openapi_object["oneOf"], _openapi_validate) : ABSENT + _openapi_field_pattern = haskey(_openapi_object, "pattern") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pattern"], _openapi_validate) : ABSENT + _openapi_field_patternproperties = haskey(_openapi_object, "patternProperties") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternProperties,Nothing}, _openapi_object["patternProperties"], _openapi_validate) : ABSENT + _openapi_field_properties = haskey(_openapi_object, "properties") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaPropsDefinitionsAdditionalValue1PatternPropertiesAdditionalValue1Properties,Nothing}, _openapi_object["properties"], _openapi_validate) : ABSENT + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_field_title = haskey(_openapi_object, "title") ? _decode(Union{Absent,Nothing,String}, _openapi_object["title"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_uniqueitems = haskey(_openapi_object, "uniqueItems") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["uniqueItems"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_embedded_resource = haskey(_openapi_object, "x-kubernetes-embedded-resource") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-embedded-resource"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_int_or_string = haskey(_openapi_object, "x-kubernetes-int-or-string") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-int-or-string"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_map_keys = haskey(_openapi_object, "x-kubernetes-list-map-keys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["x-kubernetes-list-map-keys"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_list_type = haskey(_openapi_object, "x-kubernetes-list-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-list-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_map_type = haskey(_openapi_object, "x-kubernetes-map-type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["x-kubernetes-map-type"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_preserve_unknown_fields = haskey(_openapi_object, "x-kubernetes-preserve-unknown-fields") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["x-kubernetes-preserve-unknown-fields"], _openapi_validate) : ABSENT + _openapi_field_x_kubernetes_validations = haskey(_openapi_object, "x-kubernetes-validations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1ValidationRule}}}, _openapi_object["x-kubernetes-validations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("\$ref","\$schema","additionalItems","additionalProperties","allOf","anyOf","default","definitions","dependencies","description","enum","example","exclusiveMaximum","exclusiveMinimum","externalDocs","format","id","items","maxItems","maxLength","maxProperties","maximum","minItems","minLength","minProperties","minimum","multipleOf","not","nullable","oneOf","pattern","patternProperties","properties","required","title","type","uniqueItems","x-kubernetes-embedded-resource","x-kubernetes-int-or-string","x-kubernetes-list-map-keys","x-kubernetes-list-type","x-kubernetes-map-type","x-kubernetes-preserve-unknown-fields","x-kubernetes-validations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps(; ref = _openapi_field_ref, schema = _openapi_field_schema, additionalitems = _openapi_field_additionalitems, additionalproperties = _openapi_field_additionalproperties, allof = _openapi_field_allof, anyof = _openapi_field_anyof, default = _openapi_field_default, definitions = _openapi_field_definitions, dependencies = _openapi_field_dependencies, description = _openapi_field_description, enum = _openapi_field_enum, example = _openapi_field_example, exclusivemaximum = _openapi_field_exclusivemaximum, exclusiveminimum = _openapi_field_exclusiveminimum, externaldocs = _openapi_field_externaldocs, format = _openapi_field_format, id = _openapi_field_id, items = _openapi_field_items, maxitems = _openapi_field_maxitems, maxlength = _openapi_field_maxlength, maxproperties = _openapi_field_maxproperties, maximum = _openapi_field_maximum, minitems = _openapi_field_minitems, minlength = _openapi_field_minlength, minproperties = _openapi_field_minproperties, minimum = _openapi_field_minimum, multipleof = _openapi_field_multipleof, not = _openapi_field_not, nullable = _openapi_field_nullable, oneof = _openapi_field_oneof, pattern = _openapi_field_pattern, patternproperties = _openapi_field_patternproperties, properties = _openapi_field_properties, required = _openapi_field_required, title = _openapi_field_title, type_ = _openapi_field_type_, uniqueitems = _openapi_field_uniqueitems, x_kubernetes_embedded_resource = _openapi_field_x_kubernetes_embedded_resource, x_kubernetes_int_or_string = _openapi_field_x_kubernetes_int_or_string, x_kubernetes_list_map_keys = _openapi_field_x_kubernetes_list_map_keys, x_kubernetes_list_type = _openapi_field_x_kubernetes_list_type, x_kubernetes_map_type = _openapi_field_x_kubernetes_map_type, x_kubernetes_preserve_unknown_fields = _openapi_field_x_kubernetes_preserve_unknown_fields, x_kubernetes_validations = _openapi_field_x_kubernetes_validations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ref isa Absent || (_openapi_output["\$ref"] = _encode(_openapi_value.ref)) + _openapi_value.schema isa Absent || (_openapi_output["\$schema"] = _encode(_openapi_value.schema)) + _openapi_value.additionalitems isa Absent || (_openapi_output["additionalItems"] = _encode(_openapi_value.additionalitems)) + _openapi_value.additionalproperties isa Absent || (_openapi_output["additionalProperties"] = _encode(_openapi_value.additionalproperties)) + _openapi_value.allof isa Absent || (_openapi_output["allOf"] = _encode(_openapi_value.allof)) + _openapi_value.anyof isa Absent || (_openapi_output["anyOf"] = _encode(_openapi_value.anyof)) + _openapi_value.default isa Absent || (_openapi_output["default"] = _encode(_openapi_value.default)) + _openapi_value.definitions isa Absent || (_openapi_output["definitions"] = _encode(_openapi_value.definitions)) + _openapi_value.dependencies isa Absent || (_openapi_output["dependencies"] = _encode(_openapi_value.dependencies)) + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.enum isa Absent || (_openapi_output["enum"] = _encode(_openapi_value.enum)) + _openapi_value.example isa Absent || (_openapi_output["example"] = _encode(_openapi_value.example)) + _openapi_value.exclusivemaximum isa Absent || (_openapi_output["exclusiveMaximum"] = _encode(_openapi_value.exclusivemaximum)) + _openapi_value.exclusiveminimum isa Absent || (_openapi_output["exclusiveMinimum"] = _encode(_openapi_value.exclusiveminimum)) + _openapi_value.externaldocs isa Absent || (_openapi_output["externalDocs"] = _encode(_openapi_value.externaldocs)) + _openapi_value.format isa Absent || (_openapi_output["format"] = _encode(_openapi_value.format)) + _openapi_value.id isa Absent || (_openapi_output["id"] = _encode(_openapi_value.id)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.maxitems isa Absent || (_openapi_output["maxItems"] = _encode(_openapi_value.maxitems)) + _openapi_value.maxlength isa Absent || (_openapi_output["maxLength"] = _encode(_openapi_value.maxlength)) + _openapi_value.maxproperties isa Absent || (_openapi_output["maxProperties"] = _encode(_openapi_value.maxproperties)) + _openapi_value.maximum isa Absent || (_openapi_output["maximum"] = _encode(_openapi_value.maximum)) + _openapi_value.minitems isa Absent || (_openapi_output["minItems"] = _encode(_openapi_value.minitems)) + _openapi_value.minlength isa Absent || (_openapi_output["minLength"] = _encode(_openapi_value.minlength)) + _openapi_value.minproperties isa Absent || (_openapi_output["minProperties"] = _encode(_openapi_value.minproperties)) + _openapi_value.minimum isa Absent || (_openapi_output["minimum"] = _encode(_openapi_value.minimum)) + _openapi_value.multipleof isa Absent || (_openapi_output["multipleOf"] = _encode(_openapi_value.multipleof)) + _openapi_value.not isa Absent || (_openapi_output["not"] = _encode(_openapi_value.not)) + _openapi_value.nullable isa Absent || (_openapi_output["nullable"] = _encode(_openapi_value.nullable)) + _openapi_value.oneof isa Absent || (_openapi_output["oneOf"] = _encode(_openapi_value.oneof)) + _openapi_value.pattern isa Absent || (_openapi_output["pattern"] = _encode(_openapi_value.pattern)) + _openapi_value.patternproperties isa Absent || (_openapi_output["patternProperties"] = _encode(_openapi_value.patternproperties)) + _openapi_value.properties isa Absent || (_openapi_output["properties"] = _encode(_openapi_value.properties)) + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + _openapi_value.title isa Absent || (_openapi_output["title"] = _encode(_openapi_value.title)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.uniqueitems isa Absent || (_openapi_output["uniqueItems"] = _encode(_openapi_value.uniqueitems)) + _openapi_value.x_kubernetes_embedded_resource isa Absent || (_openapi_output["x-kubernetes-embedded-resource"] = _encode(_openapi_value.x_kubernetes_embedded_resource)) + _openapi_value.x_kubernetes_int_or_string isa Absent || (_openapi_output["x-kubernetes-int-or-string"] = _encode(_openapi_value.x_kubernetes_int_or_string)) + _openapi_value.x_kubernetes_list_map_keys isa Absent || (_openapi_output["x-kubernetes-list-map-keys"] = _encode(_openapi_value.x_kubernetes_list_map_keys)) + _openapi_value.x_kubernetes_list_type isa Absent || (_openapi_output["x-kubernetes-list-type"] = _encode(_openapi_value.x_kubernetes_list_type)) + _openapi_value.x_kubernetes_map_type isa Absent || (_openapi_output["x-kubernetes-map-type"] = _encode(_openapi_value.x_kubernetes_map_type)) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || (_openapi_output["x-kubernetes-preserve-unknown-fields"] = _encode(_openapi_value.x_kubernetes_preserve_unknown_fields)) + _openapi_value.x_kubernetes_validations isa Absent || (_openapi_output["x-kubernetes-validations"] = _encode(_openapi_value.x_kubernetes_validations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps) + _openapi_output = Pair{String,Any}[] + _openapi_value.ref isa Absent || push!(_openapi_output, "\$ref" => _openapi_value.ref) + _openapi_value.schema isa Absent || push!(_openapi_output, "\$schema" => _openapi_value.schema) + _openapi_value.additionalitems isa Absent || push!(_openapi_output, "additionalItems" => _openapi_value.additionalitems) + _openapi_value.additionalproperties isa Absent || push!(_openapi_output, "additionalProperties" => _openapi_value.additionalproperties) + _openapi_value.allof isa Absent || push!(_openapi_output, "allOf" => _openapi_value.allof) + _openapi_value.anyof isa Absent || push!(_openapi_output, "anyOf" => _openapi_value.anyof) + _openapi_value.default isa Absent || push!(_openapi_output, "default" => _openapi_value.default) + _openapi_value.definitions isa Absent || push!(_openapi_output, "definitions" => _openapi_value.definitions) + _openapi_value.dependencies isa Absent || push!(_openapi_output, "dependencies" => _openapi_value.dependencies) + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.enum isa Absent || push!(_openapi_output, "enum" => _openapi_value.enum) + _openapi_value.example isa Absent || push!(_openapi_output, "example" => _openapi_value.example) + _openapi_value.exclusivemaximum isa Absent || push!(_openapi_output, "exclusiveMaximum" => _openapi_value.exclusivemaximum) + _openapi_value.exclusiveminimum isa Absent || push!(_openapi_output, "exclusiveMinimum" => _openapi_value.exclusiveminimum) + _openapi_value.externaldocs isa Absent || push!(_openapi_output, "externalDocs" => _openapi_value.externaldocs) + _openapi_value.format isa Absent || push!(_openapi_output, "format" => _openapi_value.format) + _openapi_value.id isa Absent || push!(_openapi_output, "id" => _openapi_value.id) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.maxitems isa Absent || push!(_openapi_output, "maxItems" => _openapi_value.maxitems) + _openapi_value.maxlength isa Absent || push!(_openapi_output, "maxLength" => _openapi_value.maxlength) + _openapi_value.maxproperties isa Absent || push!(_openapi_output, "maxProperties" => _openapi_value.maxproperties) + _openapi_value.maximum isa Absent || push!(_openapi_output, "maximum" => _openapi_value.maximum) + _openapi_value.minitems isa Absent || push!(_openapi_output, "minItems" => _openapi_value.minitems) + _openapi_value.minlength isa Absent || push!(_openapi_output, "minLength" => _openapi_value.minlength) + _openapi_value.minproperties isa Absent || push!(_openapi_output, "minProperties" => _openapi_value.minproperties) + _openapi_value.minimum isa Absent || push!(_openapi_output, "minimum" => _openapi_value.minimum) + _openapi_value.multipleof isa Absent || push!(_openapi_output, "multipleOf" => _openapi_value.multipleof) + _openapi_value.not isa Absent || push!(_openapi_output, "not" => _openapi_value.not) + _openapi_value.nullable isa Absent || push!(_openapi_output, "nullable" => _openapi_value.nullable) + _openapi_value.oneof isa Absent || push!(_openapi_output, "oneOf" => _openapi_value.oneof) + _openapi_value.pattern isa Absent || push!(_openapi_output, "pattern" => _openapi_value.pattern) + _openapi_value.patternproperties isa Absent || push!(_openapi_output, "patternProperties" => _openapi_value.patternproperties) + _openapi_value.properties isa Absent || push!(_openapi_output, "properties" => _openapi_value.properties) + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + _openapi_value.title isa Absent || push!(_openapi_output, "title" => _openapi_value.title) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.uniqueitems isa Absent || push!(_openapi_output, "uniqueItems" => _openapi_value.uniqueitems) + _openapi_value.x_kubernetes_embedded_resource isa Absent || push!(_openapi_output, "x-kubernetes-embedded-resource" => _openapi_value.x_kubernetes_embedded_resource) + _openapi_value.x_kubernetes_int_or_string isa Absent || push!(_openapi_output, "x-kubernetes-int-or-string" => _openapi_value.x_kubernetes_int_or_string) + _openapi_value.x_kubernetes_list_map_keys isa Absent || push!(_openapi_output, "x-kubernetes-list-map-keys" => _openapi_value.x_kubernetes_list_map_keys) + _openapi_value.x_kubernetes_list_type isa Absent || push!(_openapi_output, "x-kubernetes-list-type" => _openapi_value.x_kubernetes_list_type) + _openapi_value.x_kubernetes_map_type isa Absent || push!(_openapi_output, "x-kubernetes-map-type" => _openapi_value.x_kubernetes_map_type) + _openapi_value.x_kubernetes_preserve_unknown_fields isa Absent || push!(_openapi_output, "x-kubernetes-preserve-unknown-fields" => _openapi_value.x_kubernetes_preserve_unknown_fields) + _openapi_value.x_kubernetes_validations isa Absent || push!(_openapi_output, "x-kubernetes-validations" => _openapi_value.x_kubernetes_validations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation + openapiv3schema::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation") + _openapi_field_openapiv3schema = haskey(_openapi_object, "openAPIV3Schema") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1JSONSchemaProps,Nothing}, _openapi_object["openAPIV3Schema"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("openAPIV3Schema",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation(; openapiv3schema = _openapi_field_openapiv3schema, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.openapiv3schema isa Absent || (_openapi_output["openAPIV3Schema"] = _encode(_openapi_value.openapiv3schema)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation) + _openapi_output = Pair{String,Any}[] + _openapi_value.openapiv3schema isa Absent || push!(_openapi_output, "openAPIV3Schema" => _openapi_value.openapiv3schema) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField + jsonpath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField") + _openapi_field_jsonpath = _decode(String, _required(_openapi_object, "jsonPath", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("jsonPath",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField(; jsonpath = _openapi_field_jsonpath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.jsonpath isa Absent || (_openapi_output["jsonPath"] = _encode(_openapi_value.jsonpath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.SelectableField"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField) + _openapi_output = Pair{String,Any}[] + _openapi_value.jsonpath isa Absent || push!(_openapi_output, "jsonPath" => _openapi_value.jsonpath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale + labelselectorpath::Union{Absent,Nothing,String} = ABSENT + specreplicaspath::String + statusreplicaspath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale") + _openapi_field_labelselectorpath = haskey(_openapi_object, "labelSelectorPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["labelSelectorPath"], _openapi_validate) : ABSENT + _openapi_field_specreplicaspath = _decode(String, _required(_openapi_object, "specReplicasPath", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale"), _openapi_validate) + _openapi_field_statusreplicaspath = _decode(String, _required(_openapi_object, "statusReplicasPath", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelectorPath","specReplicasPath","statusReplicasPath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale(; labelselectorpath = _openapi_field_labelselectorpath, specreplicaspath = _openapi_field_specreplicaspath, statusreplicaspath = _openapi_field_statusreplicaspath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselectorpath isa Absent || (_openapi_output["labelSelectorPath"] = _encode(_openapi_value.labelselectorpath)) + _openapi_value.specreplicaspath isa Absent || (_openapi_output["specReplicasPath"] = _encode(_openapi_value.specreplicaspath)) + _openapi_value.statusreplicaspath isa Absent || (_openapi_output["statusReplicasPath"] = _encode(_openapi_value.statusreplicaspath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselectorpath isa Absent || push!(_openapi_output, "labelSelectorPath" => _openapi_value.labelselectorpath) + _openapi_value.specreplicaspath isa Absent || push!(_openapi_output, "specReplicasPath" => _openapi_value.specreplicaspath) + _openapi_value.statusreplicaspath isa Absent || push!(_openapi_output, "statusReplicasPath" => _openapi_value.statusreplicaspath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources + scale::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale,Nothing} = ABSENT + status::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources") + _openapi_field_scale = haskey(_openapi_object, "scale") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceScale,Nothing}, _openapi_object["scale"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresourceStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("scale","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources(; scale = _openapi_field_scale, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.scale isa Absent || (_openapi_output["scale"] = _encode(_openapi_value.scale)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources) + _openapi_output = Pair{String,Any}[] + _openapi_value.scale isa Absent || push!(_openapi_output, "scale" => _openapi_value.scale) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion + additionalprintercolumns::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition}}} = ABSENT + deprecated::Union{Absent,Bool,Nothing} = ABSENT + deprecationwarning::Union{Absent,Nothing,String} = ABSENT + name::String + schema::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation,Nothing} = ABSENT + selectablefields::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField}}} = ABSENT + served::Bool + storage::Bool + subresources::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion") + _openapi_field_additionalprintercolumns = haskey(_openapi_object, "additionalPrinterColumns") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceColumnDefinition}}}, _openapi_object["additionalPrinterColumns"], _openapi_validate) : ABSENT + _openapi_field_deprecated = haskey(_openapi_object, "deprecated") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["deprecated"], _openapi_validate) : ABSENT + _openapi_field_deprecationwarning = haskey(_openapi_object, "deprecationWarning") ? _decode(Union{Absent,Nothing,String}, _openapi_object["deprecationWarning"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion"), _openapi_validate) + _openapi_field_schema = haskey(_openapi_object, "schema") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceValidation,Nothing}, _openapi_object["schema"], _openapi_validate) : ABSENT + _openapi_field_selectablefields = haskey(_openapi_object, "selectableFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1SelectableField}}}, _openapi_object["selectableFields"], _openapi_validate) : ABSENT + _openapi_field_served = _decode(Bool, _required(_openapi_object, "served", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion"), _openapi_validate) + _openapi_field_storage = _decode(Bool, _required(_openapi_object, "storage", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion"), _openapi_validate) + _openapi_field_subresources = haskey(_openapi_object, "subresources") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceSubresources,Nothing}, _openapi_object["subresources"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("additionalPrinterColumns","deprecated","deprecationWarning","name","schema","selectableFields","served","storage","subresources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion(; additionalprintercolumns = _openapi_field_additionalprintercolumns, deprecated = _openapi_field_deprecated, deprecationwarning = _openapi_field_deprecationwarning, name = _openapi_field_name, schema = _openapi_field_schema, selectablefields = _openapi_field_selectablefields, served = _openapi_field_served, storage = _openapi_field_storage, subresources = _openapi_field_subresources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.additionalprintercolumns isa Absent || (_openapi_output["additionalPrinterColumns"] = _encode(_openapi_value.additionalprintercolumns)) + _openapi_value.deprecated isa Absent || (_openapi_output["deprecated"] = _encode(_openapi_value.deprecated)) + _openapi_value.deprecationwarning isa Absent || (_openapi_output["deprecationWarning"] = _encode(_openapi_value.deprecationwarning)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.schema isa Absent || (_openapi_output["schema"] = _encode(_openapi_value.schema)) + _openapi_value.selectablefields isa Absent || (_openapi_output["selectableFields"] = _encode(_openapi_value.selectablefields)) + _openapi_value.served isa Absent || (_openapi_output["served"] = _encode(_openapi_value.served)) + _openapi_value.storage isa Absent || (_openapi_output["storage"] = _encode(_openapi_value.storage)) + _openapi_value.subresources isa Absent || (_openapi_output["subresources"] = _encode(_openapi_value.subresources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion) + _openapi_output = Pair{String,Any}[] + _openapi_value.additionalprintercolumns isa Absent || push!(_openapi_output, "additionalPrinterColumns" => _openapi_value.additionalprintercolumns) + _openapi_value.deprecated isa Absent || push!(_openapi_output, "deprecated" => _openapi_value.deprecated) + _openapi_value.deprecationwarning isa Absent || push!(_openapi_output, "deprecationWarning" => _openapi_value.deprecationwarning) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.schema isa Absent || push!(_openapi_output, "schema" => _openapi_value.schema) + _openapi_value.selectablefields isa Absent || push!(_openapi_output, "selectableFields" => _openapi_value.selectablefields) + _openapi_value.served isa Absent || push!(_openapi_output, "served" => _openapi_value.served) + _openapi_value.storage isa Absent || push!(_openapi_output, "storage" => _openapi_value.storage) + _openapi_value.subresources isa Absent || push!(_openapi_output, "subresources" => _openapi_value.subresources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec + conversion::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion,Nothing} = ABSENT + group::String + names::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames + preserveunknownfields::Union{Absent,Bool,Nothing} = ABSENT + scope::String + versions::Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec") + _openapi_field_conversion = haskey(_openapi_object, "conversion") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceConversion,Nothing}, _openapi_object["conversion"], _openapi_validate) : ABSENT + _openapi_field_group = _decode(String, _required(_openapi_object, "group", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"), _openapi_validate) + _openapi_field_names = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames, _required(_openapi_object, "names", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"), _openapi_validate) + _openapi_field_preserveunknownfields = haskey(_openapi_object, "preserveUnknownFields") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["preserveUnknownFields"], _openapi_validate) : ABSENT + _openapi_field_scope = _decode(String, _required(_openapi_object, "scope", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"), _openapi_validate) + _openapi_field_versions = _decode(Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionVersion}}, _required(_openapi_object, "versions", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conversion","group","names","preserveUnknownFields","scope","versions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec(; conversion = _openapi_field_conversion, group = _openapi_field_group, names = _openapi_field_names, preserveunknownfields = _openapi_field_preserveunknownfields, scope = _openapi_field_scope, versions = _openapi_field_versions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conversion isa Absent || (_openapi_output["conversion"] = _encode(_openapi_value.conversion)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.names isa Absent || (_openapi_output["names"] = _encode(_openapi_value.names)) + _openapi_value.preserveunknownfields isa Absent || (_openapi_output["preserveUnknownFields"] = _encode(_openapi_value.preserveunknownfields)) + _openapi_value.scope isa Absent || (_openapi_output["scope"] = _encode(_openapi_value.scope)) + _openapi_value.versions isa Absent || (_openapi_output["versions"] = _encode(_openapi_value.versions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.conversion isa Absent || push!(_openapi_output, "conversion" => _openapi_value.conversion) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.names isa Absent || push!(_openapi_output, "names" => _openapi_value.names) + _openapi_value.preserveunknownfields isa Absent || push!(_openapi_output, "preserveUnknownFields" => _openapi_value.preserveunknownfields) + _openapi_value.scope isa Absent || push!(_openapi_output, "scope" => _openapi_value.scope) + _openapi_value.versions isa Absent || push!(_openapi_output, "versions" => _openapi_value.versions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","observedGeneration","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, observedgeneration = _openapi_field_observedgeneration, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus + acceptednames::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition}}} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + storedversions::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus") + _openapi_field_acceptednames = haskey(_openapi_object, "acceptedNames") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionNames,Nothing}, _openapi_object["acceptedNames"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_storedversions = haskey(_openapi_object, "storedVersions") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["storedVersions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("acceptedNames","conditions","observedGeneration","storedVersions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus(; acceptednames = _openapi_field_acceptednames, conditions = _openapi_field_conditions, observedgeneration = _openapi_field_observedgeneration, storedversions = _openapi_field_storedversions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.acceptednames isa Absent || (_openapi_output["acceptedNames"] = _encode(_openapi_value.acceptednames)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.storedversions isa Absent || (_openapi_output["storedVersions"] = _encode(_openapi_value.storedversions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.acceptednames isa Absent || push!(_openapi_output, "acceptedNames" => _openapi_value.acceptednames) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.storedversions isa Absent || push!(_openapi_output, "storedVersions" => _openapi_value.storedversions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec + status::Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionSpec, _required(_openapi_object, "spec", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition"), _openapi_validate) + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList}, value) = _decode(IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, value, true) +function _decode(::Type{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList"), _openapi_raw, "decoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition}}, _required(_openapi_object, "items", "IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList"), _openapi_output, "encoding IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getapiextensionsv1apiresources = ( + id = "getApiextensionsV1APIResources", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getapiextensionsv1apiresources(...)\n\nget available resources\n\n`GET /apis/apiextensions.k8s.io/v1/`" +function getapiextensionsv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getapiextensionsv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteapiextensionsv1collectioncustomresourcedefinition = ( + id = "deleteApiextensionsV1CollectionCustomResourceDefinition", + method = "DELETE", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteapiextensionsv1collectioncustomresourcedefinition(...)\n\ndelete collection of CustomResourceDefinition\n\n`DELETE /apis/apiextensions.k8s.io/v1/customresourcedefinitions`" +function deleteapiextensionsv1collectioncustomresourcedefinition(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteapiextensionsv1collectioncustomresourcedefinition, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listapiextensionsv1customresourcedefinition = ( + id = "listApiextensionsV1CustomResourceDefinition", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listapiextensionsv1customresourcedefinition(...)\n\nlist or watch objects of kind CustomResourceDefinition\n\n`GET /apis/apiextensions.k8s.io/v1/customresourcedefinitions`" +function listapiextensionsv1customresourcedefinition(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listapiextensionsv1customresourcedefinition, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createapiextensionsv1customresourcedefinition = ( + id = "createApiextensionsV1CustomResourceDefinition", + method = "POST", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createapiextensionsv1customresourcedefinition(...)\n\ncreate a CustomResourceDefinition\n\n`POST /apis/apiextensions.k8s.io/v1/customresourcedefinitions`" +function createapiextensionsv1customresourcedefinition(body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createapiextensionsv1customresourcedefinition, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteapiextensionsv1customresourcedefinition = ( + id = "deleteApiextensionsV1CustomResourceDefinition", + method = "DELETE", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteapiextensionsv1customresourcedefinition(...)\n\ndelete a CustomResourceDefinition\n\n`DELETE /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}`" +function deleteapiextensionsv1customresourcedefinition(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteapiextensionsv1customresourcedefinition, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readapiextensionsv1customresourcedefinition = ( + id = "readApiextensionsV1CustomResourceDefinition", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readapiextensionsv1customresourcedefinition(...)\n\nread the specified CustomResourceDefinition\n\n`GET /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}`" +function readapiextensionsv1customresourcedefinition(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readapiextensionsv1customresourcedefinition, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchapiextensionsv1customresourcedefinition = ( + id = "patchApiextensionsV1CustomResourceDefinition", + method = "PATCH", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchapiextensionsv1customresourcedefinition(...)\n\npartially update the specified CustomResourceDefinition\n\n`PATCH /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}`" +function patchapiextensionsv1customresourcedefinition(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchapiextensionsv1customresourcedefinition, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceapiextensionsv1customresourcedefinition = ( + id = "replaceApiextensionsV1CustomResourceDefinition", + method = "PUT", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceapiextensionsv1customresourcedefinition(...)\n\nreplace the specified CustomResourceDefinition\n\n`PUT /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}`" +function replaceapiextensionsv1customresourcedefinition(name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceapiextensionsv1customresourcedefinition, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readapiextensionsv1customresourcedefinitionstatus = ( + id = "readApiextensionsV1CustomResourceDefinitionStatus", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readapiextensionsv1customresourcedefinitionstatus(...)\n\nread status of the specified CustomResourceDefinition\n\n`GET /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status`" +function readapiextensionsv1customresourcedefinitionstatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readapiextensionsv1customresourcedefinitionstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchapiextensionsv1customresourcedefinitionstatus = ( + id = "patchApiextensionsV1CustomResourceDefinitionStatus", + method = "PATCH", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchapiextensionsv1customresourcedefinitionstatus(...)\n\npartially update status of the specified CustomResourceDefinition\n\n`PATCH /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status`" +function patchapiextensionsv1customresourcedefinitionstatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchapiextensionsv1customresourcedefinitionstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceapiextensionsv1customresourcedefinitionstatus = ( + id = "replaceApiextensionsV1CustomResourceDefinitionStatus", + method = "PUT", + path = "/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1customresourcedefinitions~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceapiextensionsv1customresourcedefinitionstatus(...)\n\nreplace status of the specified CustomResourceDefinition\n\n`PUT /apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status`" +function replaceapiextensionsv1customresourcedefinitionstatus(name::String, body::IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceapiextensionsv1customresourcedefinitionstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchapiextensionsv1customresourcedefinitionlist = ( + id = "watchApiextensionsV1CustomResourceDefinitionList", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchapiextensionsv1customresourcedefinitionlist(...)\n\nwatch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions`" +function watchapiextensionsv1customresourcedefinitionlist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchapiextensionsv1customresourcedefinitionlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchapiextensionsv1customresourcedefinition = ( + id = "watchApiextensionsV1CustomResourceDefinition", + method = "GET", + path = "/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-519e65c07121bf63277c.json", pointer = "/paths/~1apis~1apiextensions.k8s.io~1v1~1watch~1customresourcedefinitions~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchapiextensionsv1customresourcedefinition(...)\n\nwatch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}`" +function watchapiextensionsv1customresourcedefinition(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchapiextensionsv1customresourcedefinition, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sApiextensionsK8sIoV1 diff --git a/src/ApiImpl/generated/K8sApiregistrationK8sIoV1.jl b/src/ApiImpl/generated/K8sApiregistrationK8sIoV1.jl new file mode 100644 index 00000000..8089e0d8 --- /dev/null +++ b/src/ApiImpl/generated/K8sApiregistrationK8sIoV1.jl @@ -0,0 +1,1726 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sApiregistrationK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", retrieval = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\":{\"description\":\"APIService represents a server for a particular GroupVersion. Name must be \\\"version.group\\\".\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}]},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition\":{\"description\":\"APIServiceCondition describes the state of an APIService at a particular point\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Human-readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"Unique, one-word, CamelCase reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status is the status of the condition. Can be True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type is the type of the condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\":{\"description\":\"APIServiceList is a list of APIService objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of APIService\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIServiceList\",\"version\":\"v1\"}]},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec\":{\"description\":\"APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.\",\"properties\":{\"caBundle\":{\"description\":\"CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used.\",\"format\":\"byte\",\"type\":\"string\",\"x-kubernetes-list-type\":\"atomic\"},\"group\":{\"description\":\"Group is the API group name this server hosts\",\"type\":\"string\"},\"groupPriorityMinimum\":{\"default\":0,\"description\":\"GroupPriorityMinimum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMinimum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s\",\"format\":\"int32\",\"type\":\"integer\"},\"insecureSkipTLSVerify\":{\"description\":\"InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead.\",\"type\":\"boolean\"},\"service\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference\"},\"version\":{\"description\":\"Version is the API version this server hosts. For example, \\\"v1\\\"\",\"type\":\"string\"},\"versionPriority\":{\"default\":0,\"description\":\"VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \\\"kube-like\\\", it will sort above non \\\"kube-like\\\" version strings, which are ordered lexicographically. \\\"Kube-like\\\" versions start with a \\\"v\\\", then are followed by a number (the major version), then optionally the string \\\"alpha\\\" or \\\"beta\\\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"groupPriorityMinimum\",\"versionPriority\"],\"type\":\"object\"},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus\":{\"description\":\"APIServiceStatus contains derived information about an API server\",\"properties\":{\"conditions\":{\"description\":\"Current service state of apiService.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference\":{\"description\":\"ServiceReference holds a reference to Service.legacy.k8s.io\",\"properties\":{\"name\":{\"description\":\"Name is the name of the service\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace is the namespace of the service\",\"type\":\"string\"},\"port\":{\"description\":\"If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive).\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/apiregistration.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getApiregistrationV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"]}},\"/apis/apiregistration.k8s.io/v1/apiservices\":{\"delete\":{\"description\":\"delete collection of APIService\",\"operationId\":\"deleteApiregistrationV1CollectionAPIService\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind APIService\",\"operationId\":\"listApiregistrationV1APIService\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an APIService\",\"operationId\":\"createApiregistrationV1APIService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}}},\"/apis/apiregistration.k8s.io/v1/apiservices/{name}\":{\"delete\":{\"description\":\"delete an APIService\",\"operationId\":\"deleteApiregistrationV1APIService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified APIService\",\"operationId\":\"readApiregistrationV1APIService\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the APIService\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified APIService\",\"operationId\":\"patchApiregistrationV1APIService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified APIService\",\"operationId\":\"replaceApiregistrationV1APIService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}}},\"/apis/apiregistration.k8s.io/v1/apiservices/{name}/status\":{\"get\":{\"description\":\"read status of the specified APIService\",\"operationId\":\"readApiregistrationV1APIServiceStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the APIService\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified APIService\",\"operationId\":\"patchApiregistrationV1APIServiceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified APIService\",\"operationId\":\"replaceApiregistrationV1APIServiceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}}},\"/apis/apiregistration.k8s.io/v1/watch/apiservices\":{\"get\":{\"description\":\"watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchApiregistrationV1APIServiceList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchApiregistrationV1APIService\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-c38b75200e2e4059e028.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apiregistration_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apiregistration.k8s.io\",\"kind\":\"APIService\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the APIService\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + port::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_port = haskey(_openapi_object, "port") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["port"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","namespace","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference(; name = _openapi_field_name, namespace = _openapi_field_namespace, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec + cabundle::Union{Absent,Nothing,Vector{UInt8}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + grouppriorityminimum::Int32 + insecureskiptlsverify::Union{Absent,Bool,Nothing} = ABSENT + service::Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference,Nothing} = ABSENT + version::Union{Absent,Nothing,String} = ABSENT + versionpriority::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec") + _openapi_field_cabundle = haskey(_openapi_object, "caBundle") ? _decode(Union{Absent,Nothing,Vector{UInt8}}, _openapi_object["caBundle"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_grouppriorityminimum = _decode(Int32, _required(_openapi_object, "groupPriorityMinimum", "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec"), _openapi_validate) + _openapi_field_insecureskiptlsverify = haskey(_openapi_object, "insecureSkipTLSVerify") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["insecureSkipTLSVerify"], _openapi_validate) : ABSENT + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1ServiceReference,Nothing}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_field_versionpriority = _decode(Int32, _required(_openapi_object, "versionPriority", "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("caBundle","group","groupPriorityMinimum","insecureSkipTLSVerify","service","version","versionPriority") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec(; cabundle = _openapi_field_cabundle, group = _openapi_field_group, grouppriorityminimum = _openapi_field_grouppriorityminimum, insecureskiptlsverify = _openapi_field_insecureskiptlsverify, service = _openapi_field_service, version = _openapi_field_version, versionpriority = _openapi_field_versionpriority, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cabundle isa Absent || (_openapi_output["caBundle"] = _encode(_openapi_value.cabundle)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.grouppriorityminimum isa Absent || (_openapi_output["groupPriorityMinimum"] = _encode(_openapi_value.grouppriorityminimum)) + _openapi_value.insecureskiptlsverify isa Absent || (_openapi_output["insecureSkipTLSVerify"] = _encode(_openapi_value.insecureskiptlsverify)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + _openapi_value.versionpriority isa Absent || (_openapi_output["versionPriority"] = _encode(_openapi_value.versionpriority)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.cabundle isa Absent || push!(_openapi_output, "caBundle" => _openapi_value.cabundle) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.grouppriorityminimum isa Absent || push!(_openapi_output, "groupPriorityMinimum" => _openapi_value.grouppriorityminimum) + _openapi_value.insecureskiptlsverify isa Absent || push!(_openapi_output, "insecureSkipTLSVerify" => _openapi_value.insecureskiptlsverify) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + _openapi_value.versionpriority isa Absent || push!(_openapi_output, "versionPriority" => _openapi_value.versionpriority) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus(; conditions = _openapi_field_conditions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIService + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIService"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIService") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1APIService(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIService"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList}, value) = _decode(IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, value, true) +function _decode(::Type{IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList"), _openapi_raw, "decoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sKubeAggregatorPkgApisApiregistrationV1APIService}}, _required(_openapi_object, "items", "IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/components/schemas/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList"), _openapi_output, "encoding IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getapiregistrationv1apiresources = ( + id = "getApiregistrationV1APIResources", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getapiregistrationv1apiresources(...)\n\nget available resources\n\n`GET /apis/apiregistration.k8s.io/v1/`" +function getapiregistrationv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getapiregistrationv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteapiregistrationv1collectionapiservice = ( + id = "deleteApiregistrationV1CollectionAPIService", + method = "DELETE", + path = "/apis/apiregistration.k8s.io/v1/apiservices", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteapiregistrationv1collectionapiservice(...)\n\ndelete collection of APIService\n\n`DELETE /apis/apiregistration.k8s.io/v1/apiservices`" +function deleteapiregistrationv1collectionapiservice(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteapiregistrationv1collectionapiservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listapiregistrationv1apiservice = ( + id = "listApiregistrationV1APIService", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/apiservices", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listapiregistrationv1apiservice(...)\n\nlist or watch objects of kind APIService\n\n`GET /apis/apiregistration.k8s.io/v1/apiservices`" +function listapiregistrationv1apiservice(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listapiregistrationv1apiservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createapiregistrationv1apiservice = ( + id = "createApiregistrationV1APIService", + method = "POST", + path = "/apis/apiregistration.k8s.io/v1/apiservices", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createapiregistrationv1apiservice(...)\n\ncreate an APIService\n\n`POST /apis/apiregistration.k8s.io/v1/apiservices`" +function createapiregistrationv1apiservice(body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createapiregistrationv1apiservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteapiregistrationv1apiservice = ( + id = "deleteApiregistrationV1APIService", + method = "DELETE", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteapiregistrationv1apiservice(...)\n\ndelete an APIService\n\n`DELETE /apis/apiregistration.k8s.io/v1/apiservices/{name}`" +function deleteapiregistrationv1apiservice(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteapiregistrationv1apiservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readapiregistrationv1apiservice = ( + id = "readApiregistrationV1APIService", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readapiregistrationv1apiservice(...)\n\nread the specified APIService\n\n`GET /apis/apiregistration.k8s.io/v1/apiservices/{name}`" +function readapiregistrationv1apiservice(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readapiregistrationv1apiservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchapiregistrationv1apiservice = ( + id = "patchApiregistrationV1APIService", + method = "PATCH", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchapiregistrationv1apiservice(...)\n\npartially update the specified APIService\n\n`PATCH /apis/apiregistration.k8s.io/v1/apiservices/{name}`" +function patchapiregistrationv1apiservice(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchapiregistrationv1apiservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceapiregistrationv1apiservice = ( + id = "replaceApiregistrationV1APIService", + method = "PUT", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceapiregistrationv1apiservice(...)\n\nreplace the specified APIService\n\n`PUT /apis/apiregistration.k8s.io/v1/apiservices/{name}`" +function replaceapiregistrationv1apiservice(name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceapiregistrationv1apiservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readapiregistrationv1apiservicestatus = ( + id = "readApiregistrationV1APIServiceStatus", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readapiregistrationv1apiservicestatus(...)\n\nread status of the specified APIService\n\n`GET /apis/apiregistration.k8s.io/v1/apiservices/{name}/status`" +function readapiregistrationv1apiservicestatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readapiregistrationv1apiservicestatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchapiregistrationv1apiservicestatus = ( + id = "patchApiregistrationV1APIServiceStatus", + method = "PATCH", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchapiregistrationv1apiservicestatus(...)\n\npartially update status of the specified APIService\n\n`PATCH /apis/apiregistration.k8s.io/v1/apiservices/{name}/status`" +function patchapiregistrationv1apiservicestatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchapiregistrationv1apiservicestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceapiregistrationv1apiservicestatus = ( + id = "replaceApiregistrationV1APIServiceStatus", + method = "PUT", + path = "/apis/apiregistration.k8s.io/v1/apiservices/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1apiservices~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceapiregistrationv1apiservicestatus(...)\n\nreplace status of the specified APIService\n\n`PUT /apis/apiregistration.k8s.io/v1/apiservices/{name}/status`" +function replaceapiregistrationv1apiservicestatus(name::String, body::IoK8sKubeAggregatorPkgApisApiregistrationV1APIService; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceapiregistrationv1apiservicestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchapiregistrationv1apiservicelist = ( + id = "watchApiregistrationV1APIServiceList", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/watch/apiservices", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchapiregistrationv1apiservicelist(...)\n\nwatch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apiregistration.k8s.io/v1/watch/apiservices`" +function watchapiregistrationv1apiservicelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchapiregistrationv1apiservicelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchapiregistrationv1apiservice = ( + id = "watchApiregistrationV1APIService", + method = "GET", + path = "/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-c38b75200e2e4059e028.json", pointer = "/paths/~1apis~1apiregistration.k8s.io~1v1~1watch~1apiservices~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchapiregistrationv1apiservice(...)\n\nwatch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apiregistration.k8s.io/v1/watch/apiservices/{name}`" +function watchapiregistrationv1apiservice(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchapiregistrationv1apiservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sApiregistrationK8sIoV1 diff --git a/src/ApiImpl/generated/K8sAppsV1.jl b/src/ApiImpl/generated/K8sAppsV1.jl new file mode 100644 index 00000000..3e30fb08 --- /dev/null +++ b/src/ApiImpl/generated/K8sAppsV1.jl @@ -0,0 +1,11690 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sAppsV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", retrieval = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.apps.v1.ControllerRevision\":{\"description\":\"ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"data\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"revision\":{\"default\":0,\"description\":\"Revision indicates the revision of the state represented by Data.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"revision\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.ControllerRevisionList\":{\"description\":\"ControllerRevisionList is a resource containing a list of ControllerRevision objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of ControllerRevisions\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"ControllerRevisionList\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.DaemonSet\":{\"description\":\"DaemonSet represents the configuration of a daemon set.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.DaemonSetCondition\":{\"description\":\"DaemonSetCondition describes the state of a DaemonSet at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human readable message indicating details about the transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"The reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of DaemonSet condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.DaemonSetList\":{\"description\":\"DaemonSetList is a collection of daemon sets.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"A list of daemon sets.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"DaemonSetList\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.DaemonSetSpec\":{\"description\":\"DaemonSetSpec is the specification of a daemon set.\",\"properties\":{\"minReadySeconds\":{\"description\":\"The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready).\",\"format\":\"int32\",\"type\":\"integer\"},\"revisionHistoryLimit\":{\"description\":\"The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"},\"updateStrategy\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy\"}},\"required\":[\"selector\",\"template\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.DaemonSetStatus\":{\"description\":\"DaemonSetStatus represents the current status of a daemon set.\",\"properties\":{\"collisionCount\":{\"description\":\"Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.\",\"format\":\"int32\",\"type\":\"integer\"},\"conditions\":{\"description\":\"Represents the latest available observations of a DaemonSet's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentNumberScheduled\":{\"default\":0,\"description\":\"The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/\",\"format\":\"int32\",\"type\":\"integer\"},\"desiredNumberScheduled\":{\"default\":0,\"description\":\"The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/\",\"format\":\"int32\",\"type\":\"integer\"},\"numberAvailable\":{\"description\":\"The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds)\",\"format\":\"int32\",\"type\":\"integer\"},\"numberMisscheduled\":{\"default\":0,\"description\":\"The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/\",\"format\":\"int32\",\"type\":\"integer\"},\"numberReady\":{\"default\":0,\"description\":\"numberReady is the number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition.\",\"format\":\"int32\",\"type\":\"integer\"},\"numberUnavailable\":{\"description\":\"The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds)\",\"format\":\"int32\",\"type\":\"integer\"},\"observedGeneration\":{\"description\":\"The most recent generation observed by the daemon set controller.\",\"format\":\"int64\",\"type\":\"integer\"},\"updatedNumberScheduled\":{\"description\":\"The total number of nodes that are running updated daemon pod\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"currentNumberScheduled\",\"numberMisscheduled\",\"desiredNumberScheduled\",\"numberReady\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.DaemonSetUpdateStrategy\":{\"description\":\"DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet.\",\"properties\":{\"rollingUpdate\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet\"},\"type\":{\"description\":\"Type of daemon set update. Can be \\\"RollingUpdate\\\" or \\\"OnDelete\\\". Default is RollingUpdate.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.Deployment\":{\"description\":\"Deployment enables declarative updates for Pods and ReplicaSets.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.DeploymentCondition\":{\"description\":\"DeploymentCondition describes the state of a deployment at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastUpdateTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human readable message indicating details about the transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"The reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of deployment condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.DeploymentList\":{\"description\":\"DeploymentList is a list of Deployments.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of Deployments.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"DeploymentList\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.DeploymentSpec\":{\"description\":\"DeploymentSpec is the specification of the desired behavior of the Deployment.\",\"properties\":{\"minReadySeconds\":{\"description\":\"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)\",\"format\":\"int32\",\"type\":\"integer\"},\"paused\":{\"description\":\"Indicates that the deployment is paused.\",\"type\":\"boolean\"},\"progressDeadlineSeconds\":{\"description\":\"The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s.\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"description\":\"Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"revisionHistoryLimit\":{\"description\":\"The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"strategy\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"}},\"required\":[\"selector\",\"template\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.DeploymentStatus\":{\"description\":\"DeploymentStatus is the most recently observed status of the Deployment.\",\"properties\":{\"availableReplicas\":{\"description\":\"Total number of available non-terminating pods (ready for at least minReadySeconds) targeted by this deployment.\",\"format\":\"int32\",\"type\":\"integer\"},\"collisionCount\":{\"description\":\"Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet.\",\"format\":\"int32\",\"type\":\"integer\"},\"conditions\":{\"description\":\"Represents the latest available observations of a deployment's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"observedGeneration\":{\"description\":\"The generation observed by the deployment controller.\",\"format\":\"int64\",\"type\":\"integer\"},\"readyReplicas\":{\"description\":\"Total number of non-terminating pods targeted by this Deployment with a Ready Condition.\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"description\":\"Total number of non-terminating pods targeted by this deployment (their labels match the selector).\",\"format\":\"int32\",\"type\":\"integer\"},\"terminatingReplicas\":{\"description\":\"Total number of terminating pods targeted by this deployment. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\\n\\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).\",\"format\":\"int32\",\"type\":\"integer\"},\"unavailableReplicas\":{\"description\":\"Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.\",\"format\":\"int32\",\"type\":\"integer\"},\"updatedReplicas\":{\"description\":\"Total number of non-terminating pods targeted by this deployment that have the desired template spec.\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.DeploymentStrategy\":{\"description\":\"DeploymentStrategy describes how to replace existing pods with new ones.\",\"properties\":{\"rollingUpdate\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment\"},\"type\":{\"description\":\"Type of deployment. Can be \\\"Recreate\\\" or \\\"RollingUpdate\\\". Default is RollingUpdate.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.ReplicaSet\":{\"description\":\"ReplicaSet ensures that a specified number of pod replicas are running at any given time.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.ReplicaSetCondition\":{\"description\":\"ReplicaSetCondition describes the state of a replica set at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human readable message indicating details about the transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"The reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of replica set condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.ReplicaSetList\":{\"description\":\"ReplicaSetList is a collection of ReplicaSets.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"ReplicaSetList\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.ReplicaSetSpec\":{\"description\":\"ReplicaSetSpec is the specification of a ReplicaSet.\",\"properties\":{\"minReadySeconds\":{\"description\":\"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"description\":\"Replicas is the number of desired pods. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"}},\"required\":[\"selector\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.ReplicaSetStatus\":{\"description\":\"ReplicaSetStatus represents the current status of a ReplicaSet.\",\"properties\":{\"availableReplicas\":{\"description\":\"The number of available non-terminating pods (ready for at least minReadySeconds) for this replica set.\",\"format\":\"int32\",\"type\":\"integer\"},\"conditions\":{\"description\":\"Represents the latest available observations of a replica set's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"fullyLabeledReplicas\":{\"description\":\"The number of non-terminating pods that have labels matching the labels of the pod template of the replicaset.\",\"format\":\"int32\",\"type\":\"integer\"},\"observedGeneration\":{\"description\":\"ObservedGeneration reflects the generation of the most recently observed ReplicaSet.\",\"format\":\"int64\",\"type\":\"integer\"},\"readyReplicas\":{\"description\":\"The number of non-terminating pods targeted by this ReplicaSet with a Ready Condition.\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"default\":0,\"description\":\"Replicas is the most recently observed number of non-terminating pods. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicaset\",\"format\":\"int32\",\"type\":\"integer\"},\"terminatingReplicas\":{\"description\":\"The number of terminating pods for this replica set. Terminating pods have a non-null .metadata.deletionTimestamp and have not yet reached the Failed or Succeeded .status.phase.\\n\\nThis is a beta field and requires enabling DeploymentReplicaSetTerminatingReplicas feature (enabled by default).\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"replicas\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.RollingUpdateDaemonSet\":{\"description\":\"Spec to control the desired behavior of daemon set rolling update.\",\"properties\":{\"maxSurge\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"maxUnavailable\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.RollingUpdateDeployment\":{\"description\":\"Spec to control the desired behavior of rolling update.\",\"properties\":{\"maxSurge\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"maxUnavailable\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy\":{\"description\":\"RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.\",\"properties\":{\"maxUnavailable\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"partition\":{\"description\":\"Partition indicates the ordinal at which the StatefulSet should be partitioned for updates. During a rolling update, all pods from ordinal Replicas-1 to Partition are updated. All pods from ordinal Partition-1 to 0 remain untouched. This is helpful in being able to do a canary based deployment. The default value is 0.\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSet\":{\"description\":\"StatefulSet represents a set of pods with consistent identities. Identities are defined as:\\n - Network: A single stable DNS and hostname.\\n - Storage: As many VolumeClaims as requested.\\n\\nThe StatefulSet guarantees that a given network identity will always map to the same storage identity.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.StatefulSetCondition\":{\"description\":\"StatefulSetCondition describes the state of a statefulset at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human readable message indicating details about the transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"The reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of statefulset condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSetList\":{\"description\":\"StatefulSetList is a collection of StatefulSets.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of stateful sets.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"apps\",\"kind\":\"StatefulSetList\",\"version\":\"v1\"}]},\"io.k8s.api.apps.v1.StatefulSetOrdinals\":{\"description\":\"StatefulSetOrdinals describes the policy used for replica ordinal assignment in this StatefulSet.\",\"properties\":{\"start\":{\"default\":0,\"description\":\"start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range:\\n [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas).\\nIf unset, defaults to 0. Replica indices will be in the range:\\n [0, .spec.replicas).\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy\":{\"description\":\"StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.\",\"properties\":{\"whenDeleted\":{\"description\":\"WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.\",\"type\":\"string\"},\"whenScaled\":{\"description\":\"WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSetSpec\":{\"description\":\"A StatefulSetSpec is the specification of a StatefulSet.\",\"properties\":{\"minReadySeconds\":{\"description\":\"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)\",\"format\":\"int32\",\"type\":\"integer\"},\"ordinals\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals\"},\"persistentVolumeClaimRetentionPolicy\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy\"},\"podManagementPolicy\":{\"description\":\"podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.\",\"type\":\"string\"},\"replicas\":{\"description\":\"replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"revisionHistoryLimit\":{\"description\":\"revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"serviceName\":{\"default\":\"\",\"description\":\"serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \\\"pod-specific-string\\\" is managed by the StatefulSet controller.\",\"type\":\"string\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"},\"updateStrategy\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy\"},\"volumeClaimTemplates\":{\"description\":\"volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"selector\",\"template\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSetStatus\":{\"description\":\"StatefulSetStatus represents the current state of a StatefulSet.\",\"properties\":{\"availableReplicas\":{\"default\":0,\"description\":\"Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset.\",\"format\":\"int32\",\"type\":\"integer\"},\"collisionCount\":{\"description\":\"collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.\",\"format\":\"int32\",\"type\":\"integer\"},\"conditions\":{\"description\":\"Represents the latest available observations of a statefulset's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentReplicas\":{\"description\":\"currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.\",\"format\":\"int32\",\"type\":\"integer\"},\"currentRevision\":{\"description\":\"currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.\",\"format\":\"int64\",\"type\":\"integer\"},\"readyReplicas\":{\"description\":\"readyReplicas is the number of pods created for this StatefulSet with a Ready Condition.\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"default\":0,\"description\":\"replicas is the number of Pods created by the StatefulSet controller.\",\"format\":\"int32\",\"type\":\"integer\"},\"updateRevision\":{\"description\":\"updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)\",\"type\":\"string\"},\"updatedReplicas\":{\"description\":\"updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"replicas\"],\"type\":\"object\"},\"io.k8s.api.apps.v1.StatefulSetUpdateStrategy\":{\"description\":\"StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy.\",\"properties\":{\"rollingUpdate\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy\"},\"type\":{\"description\":\"Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v1.Scale\":{\"description\":\"Scale represents a scaling request for a resource.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}]},\"io.k8s.api.autoscaling.v1.ScaleSpec\":{\"description\":\"ScaleSpec describes the attributes of a scale subresource.\",\"properties\":{\"replicas\":{\"default\":0,\"description\":\"replicas is the desired number of instances for the scaled object.\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v1.ScaleStatus\":{\"description\":\"ScaleStatus represents the current status of a scale subresource.\",\"properties\":{\"replicas\":{\"default\":0,\"description\":\"replicas is the actual number of observed instances of the scaled object.\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"description\":\"selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/\",\"type\":\"string\"}},\"required\":[\"replicas\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in AWS.\\n\\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty).\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Affinity\":{\"description\":\"Affinity is a group of affinity scheduling rules.\",\"properties\":{\"nodeAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeAffinity\"},\"podAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodAffinity\"},\"podAntiAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.AppArmorProfile\":{\"description\":\"AppArmorProfile defines a pod or container's AppArmor settings.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \\\"Localhost\\\".\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of AppArmor profile will be applied. Valid options are:\\n Localhost - a profile pre-loaded on the node.\\n RuntimeDefault - the container runtime's default profile.\\n Unconfined - no AppArmor enforcement.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.AzureDiskVolumeSource\":{\"description\":\"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.\",\"properties\":{\"cachingMode\":{\"default\":\"ReadWrite\",\"description\":\"cachingMode is the Host Caching mode: None, Read Only, Read Write.\",\"type\":\"string\"},\"diskName\":{\"default\":\"\",\"description\":\"diskName is the Name of the data disk in the blob storage\",\"type\":\"string\"},\"diskURI\":{\"default\":\"\",\"description\":\"diskURI is the URI of data disk in the blob storage\",\"type\":\"string\"},\"fsType\":{\"default\":\"ext4\",\"description\":\"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"kind\":{\"default\":\"Shared\",\"description\":\"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared\",\"type\":\"string\"},\"readOnly\":{\"default\":false,\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"}},\"required\":[\"diskName\",\"diskURI\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureFileVolumeSource\":{\"description\":\"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.\",\"properties\":{\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretName\":{\"default\":\"\",\"description\":\"secretName is the name of secret that contains Azure Storage Account Name and Key\",\"type\":\"string\"},\"shareName\":{\"default\":\"\",\"description\":\"shareName is the azure share Name\",\"type\":\"string\"}},\"required\":[\"secretName\",\"shareName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CSIVolumeSource\":{\"description\":\"Represents a source location of a volume to mount, managed by an external CSI driver\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType to mount. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.\",\"type\":\"string\"},\"nodePublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"readOnly\":{\"description\":\"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).\",\"type\":\"boolean\"},\"volumeAttributes\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.\",\"type\":\"object\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Capabilities\":{\"description\":\"Adds and removes POSIX capabilities from running containers.\",\"properties\":{\"add\":{\"description\":\"Added capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"drop\":{\"description\":\"Removed capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.CephFSVolumeSource\":{\"description\":\"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"monitors\":{\"description\":\"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretFile\":{\"description\":\"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"description\":\"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CinderVolumeSource\":{\"description\":\"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ClusterTrustBundleProjection\":{\"description\":\"ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"name\":{\"description\":\"Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.\",\"type\":\"string\"},\"optional\":{\"description\":\"If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"Relative path from the volume root to write the bundle.\",\"type\":\"string\"},\"signerName\":{\"description\":\"Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapEnvSource\":{\"description\":\"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\\n\\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapKeySelector\":{\"description\":\"Selects a key from a ConfigMap.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key to select.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ConfigMapProjection\":{\"description\":\"Adapts a ConfigMap into a projected volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapVolumeSource\":{\"description\":\"Adapts a ConfigMap into a volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Container\":{\"description\":\"A single application container that you want to run within a pod.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.\",\"type\":\"string\"},\"ports\":{\"description\":\"List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \\\"0.0.0.0\\\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container. This field cannot be set on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \\\"Always\\\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \\\"Always\\\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \\\"sidecar\\\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerPort\":{\"description\":\"ContainerPort represents a network port in a single container.\",\"properties\":{\"containerPort\":{\"default\":0,\"description\":\"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.\",\"format\":\"int32\",\"type\":\"integer\"},\"hostIP\":{\"description\":\"What host IP to bind the external port to.\",\"type\":\"string\"},\"hostPort\":{\"description\":\"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.\",\"format\":\"int32\",\"type\":\"integer\"},\"name\":{\"description\":\"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.\",\"type\":\"string\"},\"protocol\":{\"default\":\"TCP\",\"description\":\"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \\\"TCP\\\".\",\"type\":\"string\"}},\"required\":[\"containerPort\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerResizePolicy\":{\"description\":\"ContainerResizePolicy represents resource resize policy for the container.\",\"properties\":{\"resourceName\":{\"default\":\"\",\"description\":\"Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.\",\"type\":\"string\"},\"restartPolicy\":{\"default\":\"\",\"description\":\"Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.\",\"type\":\"string\"}},\"required\":[\"resourceName\",\"restartPolicy\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRule\":{\"description\":\"ContainerRestartRule describes how a container exit is handled.\",\"properties\":{\"action\":{\"description\":\"Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \\\"Restart\\\" to restart the container.\",\"type\":\"string\"},\"exitCodes\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\"}},\"required\":[\"action\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\":{\"description\":\"ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.\",\"properties\":{\"operator\":{\"description\":\"Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\\n set of specified values.\\n- NotIn: the requirement is satisfied if the container exit code is\\n not in the set of specified values.\",\"type\":\"string\"},\"values\":{\"description\":\"Specifies the set of values to check for container exit codes. At most 255 elements are allowed.\",\"items\":{\"default\":0,\"format\":\"int32\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"required\":[\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIProjection\":{\"description\":\"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"Items is a list of DownwardAPIVolume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeFile\":{\"description\":\"DownwardAPIVolumeFile represents information to create the file containing the pod field\",\"properties\":{\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"mode\":{\"description\":\"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'\",\"type\":\"string\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeSource\":{\"description\":\"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"Items is a list of downward API volume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.EmptyDirVolumeSource\":{\"description\":\"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.\",\"properties\":{\"medium\":{\"description\":\"medium represents what type of storage medium should back this directory. The default is \\\"\\\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir\",\"type\":\"string\"},\"sizeLimit\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EnvFromSource\":{\"description\":\"EnvFromSource represents the source of a set of ConfigMaps or Secrets\",\"properties\":{\"configMapRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource\"},\"prefix\":{\"description\":\"Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecretEnvSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVar\":{\"description\":\"EnvVar represents an environment variable present in a Container.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"value\":{\"description\":\"Variable references \$(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \\\"\\\".\",\"type\":\"string\"},\"valueFrom\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EnvVarSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVarSource\":{\"description\":\"EnvVarSource represents a source for the value of an EnvVar.\",\"properties\":{\"configMapKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector\"},\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"fileKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.FileKeySelector\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"},\"secretKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecretKeySelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralContainer\":{\"description\":\"An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\\n\\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.\",\"type\":\"string\"},\"ports\":{\"description\":\"Ports are not allowed for ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"targetContainerName\":{\"description\":\"If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\\n\\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.\",\"type\":\"string\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralVolumeSource\":{\"description\":\"Represents an ephemeral volume that is handled by a normal storage driver.\",\"properties\":{\"volumeClaimTemplate\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ExecAction\":{\"description\":\"ExecAction describes a \\\"run in container\\\" action.\",\"properties\":{\"command\":{\"description\":\"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FCVolumeSource\":{\"description\":\"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"lun\":{\"description\":\"lun is Optional: FC target lun number\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"targetWWNs\":{\"description\":\"targetWWNs is Optional: FC target worldwide names (WWNs)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"wwids\":{\"description\":\"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FileKeySelector\":{\"description\":\"FileKeySelector selects a key of the env file.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.\",\"type\":\"string\"},\"optional\":{\"default\":false,\"description\":\"Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\\n\\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.\",\"type\":\"string\"},\"volumeName\":{\"default\":\"\",\"description\":\"The name of the volume mount containing the env file.\",\"type\":\"string\"}},\"required\":[\"volumeName\",\"path\",\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.FlexVolumeSource\":{\"description\":\"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default filesystem depends on FlexVolume script.\",\"type\":\"string\"},\"options\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"options is Optional: this field holds extra command options if any.\",\"type\":\"object\"},\"readOnly\":{\"description\":\"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FlockerVolumeSource\":{\"description\":\"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"datasetName\":{\"description\":\"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated\",\"type\":\"string\"},\"datasetUUID\":{\"description\":\"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in Google Compute Engine.\\n\\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"format\":\"int32\",\"type\":\"integer\"},\"pdName\":{\"default\":\"\",\"description\":\"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"boolean\"}},\"required\":[\"pdName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GRPCAction\":{\"description\":\"GRPCAction specifies an action involving a GRPC service.\",\"properties\":{\"port\":{\"default\":0,\"description\":\"Port number of the gRPC service. Number must be in the range 1 to 65535.\",\"format\":\"int32\",\"type\":\"integer\"},\"service\":{\"default\":\"\",\"description\":\"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\\n\\nIf this is not specified, the default behavior is defined by gRPC.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GitRepoVolumeSource\":{\"description\":\"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\\n\\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.\",\"properties\":{\"directory\":{\"description\":\"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.\",\"type\":\"string\"},\"repository\":{\"default\":\"\",\"description\":\"repository is the URL\",\"type\":\"string\"},\"revision\":{\"description\":\"revision is the commit hash for the specified revision.\",\"type\":\"string\"}},\"required\":[\"repository\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GlusterfsVolumeSource\":{\"description\":\"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"endpoints\":{\"default\":\"\",\"description\":\"endpoints is the endpoint name that details Glusterfs topology.\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"boolean\"}},\"required\":[\"endpoints\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPGetAction\":{\"description\":\"HTTPGetAction describes an action based on HTTP Get requests.\",\"properties\":{\"host\":{\"description\":\"Host name to connect to, defaults to the pod IP. You probably want to set \\\"Host\\\" in httpHeaders instead.\",\"type\":\"string\"},\"httpHeaders\":{\"description\":\"Custom headers to set in the request. HTTP allows repeated headers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.HTTPHeader\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"Path to access on the HTTP server.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"scheme\":{\"description\":\"Scheme to use for connecting to the host. Defaults to HTTP.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPHeader\":{\"description\":\"HTTPHeader describes a custom header to be used in HTTP probes\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"The header field value\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostAlias\":{\"description\":\"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.\",\"properties\":{\"hostnames\":{\"description\":\"Hostnames for the above IP address.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ip\":{\"default\":\"\",\"description\":\"IP address of the host file entry.\",\"type\":\"string\"}},\"required\":[\"ip\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostPathVolumeSource\":{\"description\":\"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"},\"type\":{\"description\":\"type for HostPath Volume Defaults to \\\"\\\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ISCSIVolumeSource\":{\"description\":\"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.\",\"properties\":{\"chapAuthDiscovery\":{\"description\":\"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication\",\"type\":\"boolean\"},\"chapAuthSession\":{\"description\":\"chapAuthSession defines whether support iSCSI Session CHAP authentication\",\"type\":\"boolean\"},\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi\",\"type\":\"string\"},\"initiatorName\":{\"description\":\"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.\",\"type\":\"string\"},\"iqn\":{\"default\":\"\",\"description\":\"iqn is the target iSCSI Qualified Name.\",\"type\":\"string\"},\"iscsiInterface\":{\"default\":\"default\",\"description\":\"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).\",\"type\":\"string\"},\"lun\":{\"default\":0,\"description\":\"lun represents iSCSI Target Lun number.\",\"format\":\"int32\",\"type\":\"integer\"},\"portals\":{\"description\":\"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"targetPortal\":{\"default\":\"\",\"description\":\"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"type\":\"string\"}},\"required\":[\"targetPortal\",\"iqn\",\"lun\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ImageVolumeSource\":{\"description\":\"ImageVolumeSource represents a image volume resource.\",\"properties\":{\"pullPolicy\":{\"description\":\"Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.\",\"type\":\"string\"},\"reference\":{\"description\":\"Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.KeyToPath\":{\"description\":\"Maps a string key to a path within a volume.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the key to project.\",\"type\":\"string\"},\"mode\":{\"description\":\"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.\",\"type\":\"string\"}},\"required\":[\"key\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Lifecycle\":{\"description\":\"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.\",\"properties\":{\"postStart\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"preStop\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"stopSignal\":{\"description\":\"StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LifecycleHandler\":{\"description\":\"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"sleep\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SleepAction\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LocalObjectReference\":{\"description\":\"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ModifyVolumeStatus\":{\"description\":\"ModifyVolumeStatus represents the status object of ControllerModifyVolume operation\",\"properties\":{\"status\":{\"default\":\"\",\"description\":\"status is the status of the ControllerModifyVolume operation. It can be in any of following states:\\n - Pending\\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\\n the specified VolumeAttributesClass not existing.\\n - InProgress\\n InProgress indicates that the volume is being modified.\\n - Infeasible\\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\\n\\t resolve the error, a valid VolumeAttributesClass needs to be specified.\\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.\",\"type\":\"string\"},\"targetVolumeAttributesClassName\":{\"description\":\"targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled\",\"type\":\"string\"}},\"required\":[\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NFSVolumeSource\":{\"description\":\"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"boolean\"},\"server\":{\"default\":\"\",\"description\":\"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"}},\"required\":[\"server\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeAffinity\":{\"description\":\"Node affinity is a group of node affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeSelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelector\":{\"description\":\"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.\",\"properties\":{\"nodeSelectorTerms\":{\"description\":\"Required. A list of node selector terms. The terms are ORed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"nodeSelectorTerms\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NodeSelectorRequirement\":{\"description\":\"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelectorTerm\":{\"description\":\"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\",\"properties\":{\"matchExpressions\":{\"description\":\"A list of node selector requirements by node's labels.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchFields\":{\"description\":\"A list of node selector requirements by node's fields.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ObjectFieldSelector\":{\"description\":\"ObjectFieldSelector selects an APIVersioned field of an object.\",\"properties\":{\"apiVersion\":{\"description\":\"Version of the schema the FieldPath is written in terms of, defaults to \\\"v1\\\".\",\"type\":\"string\"},\"fieldPath\":{\"default\":\"\",\"description\":\"Path of the field to select in the specified API version.\",\"type\":\"string\"}},\"required\":[\"fieldPath\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.PersistentVolumeClaim\":{\"description\":\"PersistentVolumeClaim is a user's request for and claim to a persistent volume\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PersistentVolumeClaimCondition\":{\"description\":\"PersistentVolumeClaimCondition contains details about state of pvc\",\"properties\":{\"lastProbeTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message is the human-readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \\\"Resizing\\\" that means the underlying persistent volume is being resized.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimSpec\":{\"description\":\"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"dataSource\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference\"},\"dataSourceRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.TypedObjectReference\"},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"storageClassName\":{\"description\":\"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1\",\"type\":\"string\"},\"volumeAttributesClassName\":{\"description\":\"volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\",\"type\":\"string\"},\"volumeMode\":{\"description\":\"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the binding reference to the PersistentVolume backing this claim.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimStatus\":{\"description\":\"PersistentVolumeClaimStatus is the current status of a persistent volume claim.\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"allocatedResourceStatuses\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\\n\\t* Un-prefixed keys:\\n\\t\\t- storage - the capacity of the volume.\\n\\t* Custom resources must use implementation-defined prefixed names such as \\\"example.com/my-custom-resource\\\"\\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\\n\\nClaimResourceStatus can be in any of following states:\\n\\t- ControllerResizeInProgress:\\n\\t\\tState set when resize controller starts resizing the volume in control-plane.\\n\\t- ControllerResizeFailed:\\n\\t\\tState set when resize has failed in resize controller with a terminal error.\\n\\t- NodeResizePending:\\n\\t\\tState set when resize controller has finished resizing the volume but further resizing of\\n\\t\\tvolume is needed on the node.\\n\\t- NodeResizeInProgress:\\n\\t\\tState set when kubelet starts resizing the volume.\\n\\t- NodeResizeFailed:\\n\\t\\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\\n\\t\\tNodeResizeFailed.\\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\\n\\t- pvc.status.allocatedResourceStatus['storage'] = \\\"ControllerResizeInProgress\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"ControllerResizeFailed\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizePending\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizeInProgress\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizeFailed\\\"\\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\\n\\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.\",\"type\":\"object\",\"x-kubernetes-map-type\":\"granular\"},\"allocatedResources\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\\n\\t* Un-prefixed keys:\\n\\t\\t- storage - the capacity of the volume.\\n\\t* Custom resources must use implementation-defined prefixed names such as \\\"example.com/my-custom-resource\\\"\\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\\n\\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\\n\\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.\",\"type\":\"object\"},\"capacity\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"capacity represents the actual resources of the underlying volume.\",\"type\":\"object\"},\"conditions\":{\"description\":\"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentVolumeAttributesClassName\":{\"description\":\"currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim\",\"type\":\"string\"},\"modifyVolumeStatus\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus\"},\"phase\":{\"description\":\"phase represents the current phase of PersistentVolumeClaim.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimTemplate\":{\"description\":\"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec\"}},\"required\":[\"spec\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\":{\"description\":\"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).\",\"properties\":{\"claimName\":{\"default\":\"\",\"description\":\"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.\",\"type\":\"boolean\"}},\"required\":[\"claimName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\":{\"description\":\"Represents a Photon Controller persistent disk resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"pdID\":{\"default\":\"\",\"description\":\"pdID is the ID that identifies Photon Controller persistent disk\",\"type\":\"string\"}},\"required\":[\"pdID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodAffinity\":{\"description\":\"Pod affinity is a group of inter pod affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodAffinityTerm\":{\"description\":\"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"mismatchLabelKeys\":{\"description\":\"MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"namespaceSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"namespaces\":{\"description\":\"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \\\"this pod's namespace\\\".\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologyKey\":{\"default\":\"\",\"description\":\"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\",\"type\":\"string\"}},\"required\":[\"topologyKey\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodAntiAffinity\":{\"description\":\"Pod anti affinity is a group of inter pod anti affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \\\"weight\\\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodCertificateProjection\":{\"description\":\"PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.\",\"properties\":{\"certificateChainPath\":{\"description\":\"Write the certificate chain at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"credentialBundlePath\":{\"description\":\"Write the credential bundle at this path in the projected volume.\\n\\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\\n\\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\\n\\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.\",\"type\":\"string\"},\"keyPath\":{\"description\":\"Write the key at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"keyType\":{\"description\":\"The type of keypair Kubelet will generate for the pod.\\n\\nValid values are \\\"RSA3072\\\", \\\"RSA4096\\\", \\\"ECDSAP256\\\", \\\"ECDSAP384\\\", \\\"ECDSAP521\\\", and \\\"ED25519\\\".\",\"type\":\"string\"},\"maxExpirationSeconds\":{\"description\":\"maxExpirationSeconds is the maximum lifetime permitted for the certificate.\\n\\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\\n\\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\\n\\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.\",\"format\":\"int32\",\"type\":\"integer\"},\"signerName\":{\"description\":\"Kubelet's generated CSRs will be addressed to this signer.\",\"type\":\"string\"},\"userAnnotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\\n\\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\\n\\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\\n\\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.\",\"type\":\"object\"}},\"required\":[\"signerName\",\"keyType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfig\":{\"description\":\"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.\",\"properties\":{\"nameservers\":{\"description\":\"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"options\":{\"description\":\"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"searches\":{\"description\":\"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfigOption\":{\"description\":\"PodDNSConfigOption defines DNS resolver options of a pod.\",\"properties\":{\"name\":{\"description\":\"Name is this DNS resolver option's name. Required.\",\"type\":\"string\"},\"value\":{\"description\":\"Value is this DNS resolver option's value.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodOS\":{\"description\":\"PodOS defines the OS parameters of a pod.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodReadinessGate\":{\"description\":\"PodReadinessGate contains the reference to a pod condition\",\"properties\":{\"conditionType\":{\"default\":\"\",\"description\":\"ConditionType refers to a condition in the pod's condition list with matching type.\",\"type\":\"string\"}},\"required\":[\"conditionType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodResourceClaim\":{\"description\":\"PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\\n\\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.\",\"type\":\"string\"},\"resourceClaimName\":{\"description\":\"ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"},\"resourceClaimTemplateName\":{\"description\":\"ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\\n\\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\\n\\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSchedulingGate\":{\"description\":\"PodSchedulingGate is associated to a Pod to guard its scheduling.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the scheduling gate. Each scheduling gate must have a unique name field.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSecurityContext\":{\"description\":\"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.\",\"properties\":{\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"fsGroup\":{\"description\":\"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\\n\\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\\n\\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"fsGroupChangePolicy\":{\"description\":\"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \\\"OnRootMismatch\\\" and \\\"Always\\\". If not specified, \\\"Always\\\" is used. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxChangePolicy\":{\"description\":\"seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \\\"MountOption\\\" and \\\"Recursive\\\".\\n\\n\\\"Recursive\\\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\\n\\n\\\"MountOption\\\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \\\"MountOption\\\" value is allowed only when SELinuxMount feature gate is enabled.\\n\\nIf not specified and SELinuxMount feature gate is enabled, \\\"MountOption\\\" is used. If not specified and SELinuxMount feature gate is disabled, \\\"MountOption\\\" is used for ReadWriteOncePod volumes and \\\"Recursive\\\" for all other volumes.\\n\\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\\n\\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"supplementalGroups\":{\"description\":\"A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"default\":0,\"format\":\"int64\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"supplementalGroupsPolicy\":{\"description\":\"Defines how supplemental groups of the first container processes are calculated. Valid values are \\\"Merge\\\" and \\\"Strict\\\". If not specified, \\\"Merge\\\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"sysctls\":{\"description\":\"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Sysctl\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodSpec\":{\"description\":\"PodSpec is a description of a pod.\",\"properties\":{\"activeDeadlineSeconds\":{\"description\":\"Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.\",\"format\":\"int64\",\"type\":\"integer\"},\"affinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Affinity\"},\"automountServiceAccountToken\":{\"description\":\"AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.\",\"type\":\"boolean\"},\"containers\":{\"description\":\"List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"dnsConfig\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfig\"},\"dnsPolicy\":{\"description\":\"Set DNS policy for the pod. Defaults to \\\"ClusterFirst\\\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.\",\"type\":\"string\"},\"enableServiceLinks\":{\"description\":\"EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.\",\"type\":\"boolean\"},\"ephemeralContainers\":{\"description\":\"List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EphemeralContainer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostAliases\":{\"description\":\"HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.HostAlias\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"ip\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"ip\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostIPC\":{\"description\":\"Use the host's ipc namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostNetwork\":{\"description\":\"Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.\",\"type\":\"boolean\"},\"hostPID\":{\"description\":\"Use the host's pid namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostUsers\":{\"description\":\"Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.\",\"type\":\"boolean\"},\"hostname\":{\"description\":\"Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.\",\"type\":\"string\"},\"hostnameOverride\":{\"description\":\"HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\\n\\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.\",\"type\":\"string\"},\"imagePullSecrets\":{\"description\":\"ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"initContainers\":{\"description\":\"List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"nodeName\":{\"description\":\"NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename\",\"type\":\"string\"},\"nodeSelector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"os\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodOS\"},\"overhead\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md\",\"type\":\"object\"},\"preemptionPolicy\":{\"description\":\"PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.\",\"type\":\"string\"},\"priority\":{\"description\":\"The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.\",\"format\":\"int32\",\"type\":\"integer\"},\"priorityClassName\":{\"description\":\"If specified, indicates the pod's priority. \\\"system-node-critical\\\" and \\\"system-cluster-critical\\\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.\",\"type\":\"string\"},\"readinessGates\":{\"description\":\"If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \\\"True\\\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodReadinessGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resourceClaims\":{\"description\":\"ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\\n\\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\\n\\nThis field is immutable.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy\",\"type\":\"string\"},\"runtimeClassName\":{\"description\":\"RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \\\"legacy\\\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class\",\"type\":\"string\"},\"schedulerName\":{\"description\":\"If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.\",\"type\":\"string\"},\"schedulingGates\":{\"description\":\"SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\\n\\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodSecurityContext\"},\"serviceAccount\":{\"description\":\"DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.\",\"type\":\"string\"},\"serviceAccountName\":{\"description\":\"ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/\",\"type\":\"string\"},\"setHostnameAsFQDN\":{\"description\":\"If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\\\\\SYSTEM\\\\\\\\CurrentControlSet\\\\\\\\Services\\\\\\\\Tcpip\\\\\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.\",\"type\":\"boolean\"},\"shareProcessNamespace\":{\"description\":\"Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.\",\"type\":\"boolean\"},\"subdomain\":{\"description\":\"If specified, the fully qualified Pod hostname will be \\\"...svc.\\\". If not specified, the pod will not have a domainname at all.\",\"type\":\"string\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.\",\"format\":\"int64\",\"type\":\"integer\"},\"tolerations\":{\"description\":\"If specified, the pod's tolerations.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Toleration\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologySpreadConstraints\":{\"description\":\"TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"topologyKey\",\"whenUnsatisfiable\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"topologyKey\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumes\":{\"description\":\"List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Volume\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"workloadRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.WorkloadReference\"}},\"required\":[\"containers\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodTemplateSpec\":{\"description\":\"PodTemplateSpec describes the data a pod should have when created from a template\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodSpec\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PortworxVolumeSource\":{\"description\":\"PortworxVolumeSource represents a Portworx volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID uniquely identifies a Portworx volume\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PreferredSchedulingTerm\":{\"description\":\"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\",\"properties\":{\"preference\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"weight\":{\"default\":0,\"description\":\"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"preference\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Probe\":{\"description\":\"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"failureThreshold\":{\"description\":\"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"grpc\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.GRPCAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"initialDelaySeconds\":{\"description\":\"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"},\"periodSeconds\":{\"description\":\"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"successThreshold\":{\"description\":\"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.\",\"format\":\"int64\",\"type\":\"integer\"},\"timeoutSeconds\":{\"description\":\"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ProjectedVolumeSource\":{\"description\":\"Represents a projected volume source\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"sources\":{\"description\":\"sources is the list of volume projections. Each entry in this list handles one source.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VolumeProjection\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.QuobyteVolumeSource\":{\"description\":\"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"group\":{\"description\":\"group to map volume access to Default is no group\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.\",\"type\":\"boolean\"},\"registry\":{\"default\":\"\",\"description\":\"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes\",\"type\":\"string\"},\"tenant\":{\"description\":\"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin\",\"type\":\"string\"},\"user\":{\"description\":\"user to map volume access to Defaults to serivceaccount user\",\"type\":\"string\"},\"volume\":{\"default\":\"\",\"description\":\"volume is a string that references an already created Quobyte volume by name.\",\"type\":\"string\"}},\"required\":[\"registry\",\"volume\"],\"type\":\"object\"},\"io.k8s.api.core.v1.RBDVolumeSource\":{\"description\":\"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"keyring\":{\"default\":\"/etc/ceph/keyring\",\"description\":\"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"monitors\":{\"description\":\"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pool\":{\"default\":\"rbd\",\"description\":\"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"default\":\"admin\",\"description\":\"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\",\"image\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceClaim\":{\"description\":\"ResourceClaim references one entry in PodSpec.ResourceClaims.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.\",\"type\":\"string\"},\"request\":{\"description\":\"Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceFieldSelector\":{\"description\":\"ResourceFieldSelector represents container resources (cpu, memory) and their output format\",\"properties\":{\"containerName\":{\"description\":\"Container name: required for volumes, optional for env vars\",\"type\":\"string\"},\"divisor\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"resource\":{\"default\":\"\",\"description\":\"Required: resource to select\",\"type\":\"string\"}},\"required\":[\"resource\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ResourceRequirements\":{\"description\":\"ResourceRequirements describes the compute resource requirements.\",\"properties\":{\"claims\":{\"description\":\"Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\\n\\nThis field depends on the DynamicResourceAllocation feature gate.\\n\\nThis field is immutable. It can only be set for containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true},\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SELinuxOptions\":{\"description\":\"SELinuxOptions are the labels to be applied to the container\",\"properties\":{\"level\":{\"description\":\"Level is SELinux level label that applies to the container.\",\"type\":\"string\"},\"role\":{\"description\":\"Role is a SELinux role label that applies to the container.\",\"type\":\"string\"},\"type\":{\"description\":\"Type is a SELinux type label that applies to the container.\",\"type\":\"string\"},\"user\":{\"description\":\"User is a SELinux user label that applies to the container.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ScaleIOVolumeSource\":{\"description\":\"ScaleIOVolumeSource represents a persistent ScaleIO volume\",\"properties\":{\"fsType\":{\"default\":\"xfs\",\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Default is \\\"xfs\\\".\",\"type\":\"string\"},\"gateway\":{\"default\":\"\",\"description\":\"gateway is the host address of the ScaleIO API Gateway.\",\"type\":\"string\"},\"protectionDomain\":{\"description\":\"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"sslEnabled\":{\"description\":\"sslEnabled Flag enable/disable SSL communication with Gateway, default false\",\"type\":\"boolean\"},\"storageMode\":{\"default\":\"ThinProvisioned\",\"description\":\"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.\",\"type\":\"string\"},\"storagePool\":{\"description\":\"storagePool is the ScaleIO Storage Pool associated with the protection domain.\",\"type\":\"string\"},\"system\":{\"default\":\"\",\"description\":\"system is the name of the storage system as configured in ScaleIO.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.\",\"type\":\"string\"}},\"required\":[\"gateway\",\"system\",\"secretRef\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SeccompProfile\":{\"description\":\"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \\\"Localhost\\\". Must NOT be set for any other type.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of seccomp profile will be applied. Valid options are:\\n\\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.SecretEnvSource\":{\"description\":\"SecretEnvSource selects a Secret to populate the environment variables with.\\n\\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretKeySelector\":{\"description\":\"SecretKeySelector selects a key of a Secret.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key of the secret to select from. Must be a valid secret key.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.SecretProjection\":{\"description\":\"Adapts a secret into a projected volume.\\n\\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional field specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretVolumeSource\":{\"description\":\"Adapts a Secret into a volume.\\n\\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"optional\":{\"description\":\"optional field specify whether the Secret or its keys must be defined\",\"type\":\"boolean\"},\"secretName\":{\"description\":\"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecurityContext\":{\"description\":\"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.\",\"properties\":{\"allowPrivilegeEscalation\":{\"description\":\"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"capabilities\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.Capabilities\"},\"privileged\":{\"description\":\"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"procMount\":{\"description\":\"procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"readOnlyRootFilesystem\":{\"description\":\"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ServiceAccountTokenProjection\":{\"description\":\"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).\",\"properties\":{\"audience\":{\"description\":\"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.\",\"type\":\"string\"},\"expirationSeconds\":{\"description\":\"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.\",\"format\":\"int64\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the path relative to the mount point of the file to project the token into.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SleepAction\":{\"description\":\"SleepAction describes a \\\"sleep\\\" action.\",\"properties\":{\"seconds\":{\"default\":0,\"description\":\"Seconds is the number of seconds to sleep.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"seconds\"],\"type\":\"object\"},\"io.k8s.api.core.v1.StorageOSVolumeSource\":{\"description\":\"Represents a StorageOS persistent volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeName\":{\"description\":\"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.\",\"type\":\"string\"},\"volumeNamespace\":{\"description\":\"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \\\"default\\\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Sysctl\":{\"description\":\"Sysctl defines a kernel parameter to be set\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of a property to set\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"Value of a property to set\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TCPSocketAction\":{\"description\":\"TCPSocketAction describes an action based on opening a socket\",\"properties\":{\"host\":{\"description\":\"Optional: Host name to connect to, defaults to the pod IP.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Toleration\":{\"description\":\"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .\",\"properties\":{\"effect\":{\"description\":\"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\",\"type\":\"string\"},\"key\":{\"description\":\"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.\",\"type\":\"string\"},\"operator\":{\"description\":\"Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).\",\"type\":\"string\"},\"tolerationSeconds\":{\"description\":\"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.\",\"format\":\"int64\",\"type\":\"integer\"},\"value\":{\"description\":\"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.TopologySpreadConstraint\":{\"description\":\"TopologySpreadConstraint specifies how to spread matching pods among the given topology.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\\n\\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"maxSkew\":{\"default\":0,\"description\":\"MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.\",\"format\":\"int32\",\"type\":\"integer\"},\"minDomains\":{\"description\":\"MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \\\"global minimum\\\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\\n\\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \\\"global minimum\\\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\",\"format\":\"int32\",\"type\":\"integer\"},\"nodeAffinityPolicy\":{\"description\":\"NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\\n\\nIf this value is nil, the behavior is equivalent to the Honor policy.\",\"type\":\"string\"},\"nodeTaintsPolicy\":{\"description\":\"NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\\n\\nIf this value is nil, the behavior is equivalent to the Ignore policy.\",\"type\":\"string\"},\"topologyKey\":{\"default\":\"\",\"description\":\"TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \\\"bucket\\\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \\\"kubernetes.io/hostname\\\", each Node is a domain of that topology. And, if TopologyKey is \\\"topology.kubernetes.io/zone\\\", each zone is a domain of that topology. It's a required field.\",\"type\":\"string\"},\"whenUnsatisfiable\":{\"default\":\"\",\"description\":\"WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\\n but giving higher precedence to topologies that would help reduce the\\n skew.\\nA constraint is considered \\\"Unsatisfiable\\\" for an incoming pod if and only if every possible node assignment for that pod would violate \\\"MaxSkew\\\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.\",\"type\":\"string\"}},\"required\":[\"maxSkew\",\"topologyKey\",\"whenUnsatisfiable\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TypedLocalObjectReference\":{\"description\":\"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.TypedObjectReference\":{\"description\":\"TypedObjectReference contains enough information to let you locate the typed referenced object\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Volume\":{\"description\":\"Volume represents a named volume in a pod that may be accessed by any container in the pod.\",\"properties\":{\"awsElasticBlockStore\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\"},\"azureDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource\"},\"azureFile\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource\"},\"cephfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource\"},\"cinder\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource\"},\"csi\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource\"},\"emptyDir\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource\"},\"ephemeral\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource\"},\"fc\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.FCVolumeSource\"},\"flexVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource\"},\"flocker\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource\"},\"gcePersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\"},\"gitRepo\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource\"},\"glusterfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource\"},\"hostPath\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource\"},\"image\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource\"},\"iscsi\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource\"},\"name\":{\"default\":\"\",\"description\":\"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"nfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource\"},\"persistentVolumeClaim\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\"},\"photonPersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\"},\"portworxVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource\"},\"projected\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource\"},\"quobyte\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource\"},\"rbd\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource\"},\"scaleIO\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource\"},\"storageos\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource\"},\"vsphereVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeDevice\":{\"description\":\"volumeDevice describes a mapping of a raw block device within a container.\",\"properties\":{\"devicePath\":{\"default\":\"\",\"description\":\"devicePath is the path inside of the container that the device will be mapped to.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name must match the name of a persistentVolumeClaim in the pod\",\"type\":\"string\"}},\"required\":[\"name\",\"devicePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeMount\":{\"description\":\"VolumeMount describes a mounting of a Volume within a container.\",\"properties\":{\"mountPath\":{\"default\":\"\",\"description\":\"Path within the container at which the volume should be mounted. Must not contain ':'.\",\"type\":\"string\"},\"mountPropagation\":{\"description\":\"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"This must match the Name of a Volume.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.\",\"type\":\"boolean\"},\"recursiveReadOnly\":{\"description\":\"RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\\n\\nIf ReadOnly is false, this field has no meaning and must be unspecified.\\n\\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\\n\\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\\n\\nIf this field is not specified, it is treated as an equivalent of Disabled.\",\"type\":\"string\"},\"subPath\":{\"description\":\"Path within the volume from which the container's volume should be mounted. Defaults to \\\"\\\" (volume's root).\",\"type\":\"string\"},\"subPathExpr\":{\"description\":\"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references \$(VAR_NAME) are expanded using the container's environment. Defaults to \\\"\\\" (volume's root). SubPathExpr and SubPath are mutually exclusive.\",\"type\":\"string\"}},\"required\":[\"name\",\"mountPath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeProjection\":{\"description\":\"Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.\",\"properties\":{\"clusterTrustBundle\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection\"},\"podCertificate\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.SecretProjection\"},\"serviceAccountToken\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeResourceRequirements\":{\"description\":\"VolumeResourceRequirements describes the storage resource requirements for a volume.\",\"properties\":{\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\":{\"description\":\"Represents a vSphere volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"storagePolicyID\":{\"description\":\"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.\",\"type\":\"string\"},\"storagePolicyName\":{\"description\":\"storagePolicyName is the storage Policy Based Management (SPBM) profile name.\",\"type\":\"string\"},\"volumePath\":{\"default\":\"\",\"description\":\"volumePath is the path that identifies vSphere volume vmdk\",\"type\":\"string\"}},\"required\":[\"volumePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WeightedPodAffinityTerm\":{\"description\":\"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\",\"properties\":{\"podAffinityTerm\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"weight\":{\"default\":0,\"description\":\"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"podAffinityTerm\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WindowsSecurityContextOptions\":{\"description\":\"WindowsSecurityContextOptions contain Windows-specific options and credentials.\",\"properties\":{\"gmsaCredentialSpec\":{\"description\":\"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.\",\"type\":\"string\"},\"gmsaCredentialSpecName\":{\"description\":\"GMSACredentialSpecName is the name of the GMSA credential spec to use.\",\"type\":\"string\"},\"hostProcess\":{\"description\":\"HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.\",\"type\":\"boolean\"},\"runAsUserName\":{\"description\":\"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.WorkloadReference\":{\"description\":\"WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.\",\"type\":\"string\"},\"podGroup\":{\"default\":\"\",\"description\":\"PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.\",\"type\":\"string\"},\"podGroupReplicaKey\":{\"description\":\"PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.\",\"type\":\"string\"}},\"required\":[\"name\",\"podGroup\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.util.intstr.IntOrString\":{\"description\":\"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.\",\"format\":\"int-or-string\",\"oneOf\":[{\"type\":\"integer\"},{\"type\":\"string\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/apps/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getAppsV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"]}},\"/apis/apps/v1/controllerrevisions\":{\"get\":{\"description\":\"list or watch objects of kind ControllerRevision\",\"operationId\":\"listAppsV1ControllerRevisionForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/daemonsets\":{\"get\":{\"description\":\"list or watch objects of kind DaemonSet\",\"operationId\":\"listAppsV1DaemonSetForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/deployments\":{\"get\":{\"description\":\"list or watch objects of kind Deployment\",\"operationId\":\"listAppsV1DeploymentForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/namespaces/{namespace}/controllerrevisions\":{\"delete\":{\"description\":\"delete collection of ControllerRevision\",\"operationId\":\"deleteAppsV1CollectionNamespacedControllerRevision\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ControllerRevision\",\"operationId\":\"listAppsV1NamespacedControllerRevision\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ControllerRevision\",\"operationId\":\"createAppsV1NamespacedControllerRevision\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}\":{\"delete\":{\"description\":\"delete a ControllerRevision\",\"operationId\":\"deleteAppsV1NamespacedControllerRevision\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ControllerRevision\",\"operationId\":\"readAppsV1NamespacedControllerRevision\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ControllerRevision\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ControllerRevision\",\"operationId\":\"patchAppsV1NamespacedControllerRevision\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ControllerRevision\",\"operationId\":\"replaceAppsV1NamespacedControllerRevision\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ControllerRevision\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/daemonsets\":{\"delete\":{\"description\":\"delete collection of DaemonSet\",\"operationId\":\"deleteAppsV1CollectionNamespacedDaemonSet\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind DaemonSet\",\"operationId\":\"listAppsV1NamespacedDaemonSet\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a DaemonSet\",\"operationId\":\"createAppsV1NamespacedDaemonSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}\":{\"delete\":{\"description\":\"delete a DaemonSet\",\"operationId\":\"deleteAppsV1NamespacedDaemonSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified DaemonSet\",\"operationId\":\"readAppsV1NamespacedDaemonSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the DaemonSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified DaemonSet\",\"operationId\":\"patchAppsV1NamespacedDaemonSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified DaemonSet\",\"operationId\":\"replaceAppsV1NamespacedDaemonSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status\":{\"get\":{\"description\":\"read status of the specified DaemonSet\",\"operationId\":\"readAppsV1NamespacedDaemonSetStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the DaemonSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified DaemonSet\",\"operationId\":\"patchAppsV1NamespacedDaemonSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified DaemonSet\",\"operationId\":\"replaceAppsV1NamespacedDaemonSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DaemonSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/deployments\":{\"delete\":{\"description\":\"delete collection of Deployment\",\"operationId\":\"deleteAppsV1CollectionNamespacedDeployment\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Deployment\",\"operationId\":\"listAppsV1NamespacedDeployment\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.DeploymentList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Deployment\",\"operationId\":\"createAppsV1NamespacedDeployment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/deployments/{name}\":{\"delete\":{\"description\":\"delete a Deployment\",\"operationId\":\"deleteAppsV1NamespacedDeployment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Deployment\",\"operationId\":\"readAppsV1NamespacedDeployment\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Deployment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Deployment\",\"operationId\":\"patchAppsV1NamespacedDeployment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Deployment\",\"operationId\":\"replaceAppsV1NamespacedDeployment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale\":{\"get\":{\"description\":\"read scale of the specified Deployment\",\"operationId\":\"readAppsV1NamespacedDeploymentScale\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Scale\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update scale of the specified Deployment\",\"operationId\":\"patchAppsV1NamespacedDeploymentScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace scale of the specified Deployment\",\"operationId\":\"replaceAppsV1NamespacedDeploymentScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status\":{\"get\":{\"description\":\"read status of the specified Deployment\",\"operationId\":\"readAppsV1NamespacedDeploymentStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Deployment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Deployment\",\"operationId\":\"patchAppsV1NamespacedDeploymentStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Deployment\",\"operationId\":\"replaceAppsV1NamespacedDeploymentStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.Deployment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/replicasets\":{\"delete\":{\"description\":\"delete collection of ReplicaSet\",\"operationId\":\"deleteAppsV1CollectionNamespacedReplicaSet\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ReplicaSet\",\"operationId\":\"listAppsV1NamespacedReplicaSet\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ReplicaSet\",\"operationId\":\"createAppsV1NamespacedReplicaSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/replicasets/{name}\":{\"delete\":{\"description\":\"delete a ReplicaSet\",\"operationId\":\"deleteAppsV1NamespacedReplicaSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ReplicaSet\",\"operationId\":\"readAppsV1NamespacedReplicaSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ReplicaSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ReplicaSet\",\"operationId\":\"patchAppsV1NamespacedReplicaSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ReplicaSet\",\"operationId\":\"replaceAppsV1NamespacedReplicaSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale\":{\"get\":{\"description\":\"read scale of the specified ReplicaSet\",\"operationId\":\"readAppsV1NamespacedReplicaSetScale\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Scale\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update scale of the specified ReplicaSet\",\"operationId\":\"patchAppsV1NamespacedReplicaSetScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace scale of the specified ReplicaSet\",\"operationId\":\"replaceAppsV1NamespacedReplicaSetScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status\":{\"get\":{\"description\":\"read status of the specified ReplicaSet\",\"operationId\":\"readAppsV1NamespacedReplicaSetStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ReplicaSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified ReplicaSet\",\"operationId\":\"patchAppsV1NamespacedReplicaSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified ReplicaSet\",\"operationId\":\"replaceAppsV1NamespacedReplicaSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/statefulsets\":{\"delete\":{\"description\":\"delete collection of StatefulSet\",\"operationId\":\"deleteAppsV1CollectionNamespacedStatefulSet\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind StatefulSet\",\"operationId\":\"listAppsV1NamespacedStatefulSet\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a StatefulSet\",\"operationId\":\"createAppsV1NamespacedStatefulSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}\":{\"delete\":{\"description\":\"delete a StatefulSet\",\"operationId\":\"deleteAppsV1NamespacedStatefulSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified StatefulSet\",\"operationId\":\"readAppsV1NamespacedStatefulSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the StatefulSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified StatefulSet\",\"operationId\":\"patchAppsV1NamespacedStatefulSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified StatefulSet\",\"operationId\":\"replaceAppsV1NamespacedStatefulSet\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale\":{\"get\":{\"description\":\"read scale of the specified StatefulSet\",\"operationId\":\"readAppsV1NamespacedStatefulSetScale\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Scale\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update scale of the specified StatefulSet\",\"operationId\":\"patchAppsV1NamespacedStatefulSetScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace scale of the specified StatefulSet\",\"operationId\":\"replaceAppsV1NamespacedStatefulSetScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}}},\"/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status\":{\"get\":{\"description\":\"read status of the specified StatefulSet\",\"operationId\":\"readAppsV1NamespacedStatefulSetStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the StatefulSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified StatefulSet\",\"operationId\":\"patchAppsV1NamespacedStatefulSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified StatefulSet\",\"operationId\":\"replaceAppsV1NamespacedStatefulSetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSet\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}}},\"/apis/apps/v1/replicasets\":{\"get\":{\"description\":\"list or watch objects of kind ReplicaSet\",\"operationId\":\"listAppsV1ReplicaSetForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.ReplicaSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/statefulsets\":{\"get\":{\"description\":\"list or watch objects of kind StatefulSet\",\"operationId\":\"listAppsV1StatefulSetForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.api.apps.v1.StatefulSetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/controllerrevisions\":{\"get\":{\"description\":\"watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1ControllerRevisionListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/daemonsets\":{\"get\":{\"description\":\"watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1DaemonSetListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/deployments\":{\"get\":{\"description\":\"watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1DeploymentListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions\":{\"get\":{\"description\":\"watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1NamespacedControllerRevisionList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAppsV1NamespacedControllerRevision\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ControllerRevision\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ControllerRevision\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/daemonsets\":{\"get\":{\"description\":\"watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1NamespacedDaemonSetList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAppsV1NamespacedDaemonSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"DaemonSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the DaemonSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/deployments\":{\"get\":{\"description\":\"watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1NamespacedDeploymentList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAppsV1NamespacedDeployment\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"Deployment\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Deployment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/replicasets\":{\"get\":{\"description\":\"watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1NamespacedReplicaSetList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAppsV1NamespacedReplicaSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ReplicaSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/statefulsets\":{\"get\":{\"description\":\"watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1NamespacedStatefulSetList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAppsV1NamespacedStatefulSet\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the StatefulSet\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/replicasets\":{\"get\":{\"description\":\"watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1ReplicaSetListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"ReplicaSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/apps/v1/watch/statefulsets\":{\"get\":{\"description\":\"watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAppsV1StatefulSetListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"apps_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"apps\",\"kind\":\"StatefulSet\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevision", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSet", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.Deployment", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSet", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSet", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ControllerRevision + apiversion::Union{Absent,Nothing,String} = ABSENT + data::Union{Absent,IoK8sApimachineryPkgRuntimeRawExtension,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + revision::Int64 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ControllerRevision}, value) = _decode(IoK8sApiAppsV1ControllerRevision, value, true) +function _decode(::Type{IoK8sApiAppsV1ControllerRevision}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevision"), _openapi_raw, "decoding IoK8sApiAppsV1ControllerRevision"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ControllerRevision") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_data = haskey(_openapi_object, "data") ? _decode(Union{Absent,IoK8sApimachineryPkgRuntimeRawExtension,Nothing}, _openapi_object["data"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_revision = _decode(Int64, _required(_openapi_object, "revision", "IoK8sApiAppsV1ControllerRevision"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","data","kind","metadata","revision") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ControllerRevision(; apiversion = _openapi_field_apiversion, data = _openapi_field_data, kind = _openapi_field_kind, metadata = _openapi_field_metadata, revision = _openapi_field_revision, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ControllerRevision) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.data isa Absent || (_openapi_output["data"] = _encode(_openapi_value.data)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.revision isa Absent || (_openapi_output["revision"] = _encode(_openapi_value.revision)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevision"), _openapi_output, "encoding IoK8sApiAppsV1ControllerRevision"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ControllerRevision) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.data isa Absent || push!(_openapi_output, "data" => _openapi_value.data) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.revision isa Absent || push!(_openapi_output, "revision" => _openapi_value.revision) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ControllerRevisionList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAppsV1ControllerRevision}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ControllerRevisionList}, value) = _decode(IoK8sApiAppsV1ControllerRevisionList, value, true) +function _decode(::Type{IoK8sApiAppsV1ControllerRevisionList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList"), _openapi_raw, "decoding IoK8sApiAppsV1ControllerRevisionList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ControllerRevisionList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAppsV1ControllerRevision}}, _required(_openapi_object, "items", "IoK8sApiAppsV1ControllerRevisionList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ControllerRevisionList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ControllerRevisionList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ControllerRevisionList"), _openapi_output, "encoding IoK8sApiAppsV1ControllerRevisionList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ControllerRevisionList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, value) = _decode(IoK8sApiCoreV1NodeSelectorRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorTerm + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + matchfields::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, value) = _decode(IoK8sApiCoreV1NodeSelectorTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorTerm") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchfields = haskey(_openapi_object, "matchFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchFields"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchFields") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorTerm(; matchexpressions = _openapi_field_matchexpressions, matchfields = _openapi_field_matchfields, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchfields isa Absent || (_openapi_output["matchFields"] = _encode(_openapi_value.matchfields)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchfields isa Absent || push!(_openapi_output, "matchFields" => _openapi_value.matchfields) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PreferredSchedulingTerm + preference::IoK8sApiCoreV1NodeSelectorTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, value) = _decode(IoK8sApiCoreV1PreferredSchedulingTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PreferredSchedulingTerm") + _openapi_field_preference = _decode(IoK8sApiCoreV1NodeSelectorTerm, _required(_openapi_object, "preference", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preference","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PreferredSchedulingTerm(; preference = _openapi_field_preference, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preference isa Absent || (_openapi_output["preference"] = _encode(_openapi_value.preference)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_output, "encoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.preference isa Absent || push!(_openapi_output, "preference" => _openapi_value.preference) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelector + nodeselectorterms::Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelector}, value) = _decode(IoK8sApiCoreV1NodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelector") + _openapi_field_nodeselectorterms = _decode(Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}}, _required(_openapi_object, "nodeSelectorTerms", "IoK8sApiCoreV1NodeSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeSelectorTerms",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelector(; nodeselectorterms = _openapi_field_nodeselectorterms, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeselectorterms isa Absent || (_openapi_output["nodeSelectorTerms"] = _encode(_openapi_value.nodeselectorterms)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeselectorterms isa Absent || push!(_openapi_output, "nodeSelectorTerms" => _openapi_value.nodeselectorterms) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeAffinity}, value) = _decode(IoK8sApiCoreV1NodeAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_output, "encoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinityTerm + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + mismatchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + namespaceselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + namespaces::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + topologykey::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, value) = _decode(IoK8sApiCoreV1PodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinityTerm") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_mismatchlabelkeys = haskey(_openapi_object, "mismatchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mismatchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_namespaceselector = haskey(_openapi_object, "namespaceSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["namespaceSelector"], _openapi_validate) : ABSENT + _openapi_field_namespaces = haskey(_openapi_object, "namespaces") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["namespaces"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1PodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","mismatchLabelKeys","namespaceSelector","namespaces","topologyKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinityTerm(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, mismatchlabelkeys = _openapi_field_mismatchlabelkeys, namespaceselector = _openapi_field_namespaceselector, namespaces = _openapi_field_namespaces, topologykey = _openapi_field_topologykey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.mismatchlabelkeys isa Absent || (_openapi_output["mismatchLabelKeys"] = _encode(_openapi_value.mismatchlabelkeys)) + _openapi_value.namespaceselector isa Absent || (_openapi_output["namespaceSelector"] = _encode(_openapi_value.namespaceselector)) + _openapi_value.namespaces isa Absent || (_openapi_output["namespaces"] = _encode(_openapi_value.namespaces)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.mismatchlabelkeys isa Absent || push!(_openapi_output, "mismatchLabelKeys" => _openapi_value.mismatchlabelkeys) + _openapi_value.namespaceselector isa Absent || push!(_openapi_output, "namespaceSelector" => _openapi_value.namespaceselector) + _openapi_value.namespaces isa Absent || push!(_openapi_output, "namespaces" => _openapi_value.namespaces) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WeightedPodAffinityTerm + podaffinityterm::IoK8sApiCoreV1PodAffinityTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, value) = _decode(IoK8sApiCoreV1WeightedPodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WeightedPodAffinityTerm") + _openapi_field_podaffinityterm = _decode(IoK8sApiCoreV1PodAffinityTerm, _required(_openapi_object, "podAffinityTerm", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("podAffinityTerm","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WeightedPodAffinityTerm(; podaffinityterm = _openapi_field_podaffinityterm, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.podaffinityterm isa Absent || (_openapi_output["podAffinityTerm"] = _encode(_openapi_value.podaffinityterm)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.podaffinityterm isa Absent || push!(_openapi_output, "podAffinityTerm" => _openapi_value.podaffinityterm) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinity}, value) = _decode(IoK8sApiCoreV1PodAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAntiAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, value) = _decode(IoK8sApiCoreV1PodAntiAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAntiAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAntiAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Affinity + nodeaffinity::Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing} = ABSENT + podaffinity::Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing} = ABSENT + podantiaffinity::Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Affinity}, value) = _decode(IoK8sApiCoreV1Affinity, value, true) +function _decode(::Type{IoK8sApiCoreV1Affinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_raw, "decoding IoK8sApiCoreV1Affinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Affinity") + _openapi_field_nodeaffinity = haskey(_openapi_object, "nodeAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing}, _openapi_object["nodeAffinity"], _openapi_validate) : ABSENT + _openapi_field_podaffinity = haskey(_openapi_object, "podAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing}, _openapi_object["podAffinity"], _openapi_validate) : ABSENT + _openapi_field_podantiaffinity = haskey(_openapi_object, "podAntiAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing}, _openapi_object["podAntiAffinity"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeAffinity","podAffinity","podAntiAffinity") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Affinity(; nodeaffinity = _openapi_field_nodeaffinity, podaffinity = _openapi_field_podaffinity, podantiaffinity = _openapi_field_podantiaffinity, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeaffinity isa Absent || (_openapi_output["nodeAffinity"] = _encode(_openapi_value.nodeaffinity)) + _openapi_value.podaffinity isa Absent || (_openapi_output["podAffinity"] = _encode(_openapi_value.podaffinity)) + _openapi_value.podantiaffinity isa Absent || (_openapi_output["podAntiAffinity"] = _encode(_openapi_value.podantiaffinity)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_output, "encoding IoK8sApiCoreV1Affinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeaffinity isa Absent || push!(_openapi_output, "nodeAffinity" => _openapi_value.nodeaffinity) + _openapi_value.podaffinity isa Absent || push!(_openapi_output, "podAffinity" => _openapi_value.podaffinity) + _openapi_value.podantiaffinity isa Absent || push!(_openapi_output, "podAntiAffinity" => _openapi_value.podantiaffinity) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, value) = _decode(IoK8sApiCoreV1ConfigMapKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1ConfigMapKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectFieldSelector + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, value) = _decode(IoK8sApiCoreV1ObjectFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectFieldSelector") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = _decode(String, _required(_openapi_object, "fieldPath", "IoK8sApiCoreV1ObjectFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectFieldSelector(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FileKeySelector + key::String + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + volumename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FileKeySelector}, value) = _decode(IoK8sApiCoreV1FileKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1FileKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FileKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_volumename = _decode(String, _required(_openapi_object, "volumeName", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","optional","path","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FileKeySelector(; key = _openapi_field_key, optional = _openapi_field_optional, path = _openapi_field_path, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceFieldSelector + containername::Union{Absent,Nothing,String} = ABSENT + divisor::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + resource::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, value) = _decode(IoK8sApiCoreV1ResourceFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceFieldSelector") + _openapi_field_containername = haskey(_openapi_object, "containerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerName"], _openapi_validate) : ABSENT + _openapi_field_divisor = haskey(_openapi_object, "divisor") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["divisor"], _openapi_validate) : ABSENT + _openapi_field_resource = _decode(String, _required(_openapi_object, "resource", "IoK8sApiCoreV1ResourceFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerName","divisor","resource") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceFieldSelector(; containername = _openapi_field_containername, divisor = _openapi_field_divisor, resource = _openapi_field_resource, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containername isa Absent || (_openapi_output["containerName"] = _encode(_openapi_value.containername)) + _openapi_value.divisor isa Absent || (_openapi_output["divisor"] = _encode(_openapi_value.divisor)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.containername isa Absent || push!(_openapi_output, "containerName" => _openapi_value.containername) + _openapi_value.divisor isa Absent || push!(_openapi_output, "divisor" => _openapi_value.divisor) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretKeySelector}, value) = _decode(IoK8sApiCoreV1SecretKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1SecretKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVarSource + configmapkeyref::Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing} = ABSENT + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + filekeyref::Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing} = ABSENT + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + secretkeyref::Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVarSource}, value) = _decode(IoK8sApiCoreV1EnvVarSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVarSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVarSource") + _openapi_field_configmapkeyref = haskey(_openapi_object, "configMapKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing}, _openapi_object["configMapKeyRef"], _openapi_validate) : ABSENT + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_filekeyref = haskey(_openapi_object, "fileKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing}, _openapi_object["fileKeyRef"], _openapi_validate) : ABSENT + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_field_secretkeyref = haskey(_openapi_object, "secretKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing}, _openapi_object["secretKeyRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapKeyRef","fieldRef","fileKeyRef","resourceFieldRef","secretKeyRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVarSource(; configmapkeyref = _openapi_field_configmapkeyref, fieldref = _openapi_field_fieldref, filekeyref = _openapi_field_filekeyref, resourcefieldref = _openapi_field_resourcefieldref, secretkeyref = _openapi_field_secretkeyref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapkeyref isa Absent || (_openapi_output["configMapKeyRef"] = _encode(_openapi_value.configmapkeyref)) + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.filekeyref isa Absent || (_openapi_output["fileKeyRef"] = _encode(_openapi_value.filekeyref)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + _openapi_value.secretkeyref isa Absent || (_openapi_output["secretKeyRef"] = _encode(_openapi_value.secretkeyref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapkeyref isa Absent || push!(_openapi_output, "configMapKeyRef" => _openapi_value.configmapkeyref) + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.filekeyref isa Absent || push!(_openapi_output, "fileKeyRef" => _openapi_value.filekeyref) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + _openapi_value.secretkeyref isa Absent || push!(_openapi_output, "secretKeyRef" => _openapi_value.secretkeyref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVar + name::String + value::Union{Absent,Nothing,String} = ABSENT + valuefrom::Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVar}, value) = _decode(IoK8sApiCoreV1EnvVar, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVar}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVar"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVar") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EnvVar"), _openapi_validate) + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_field_valuefrom = haskey(_openapi_object, "valueFrom") ? _decode(Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing}, _openapi_object["valueFrom"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value","valueFrom") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVar(; name = _openapi_field_name, value = _openapi_field_value, valuefrom = _openapi_field_valuefrom, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + _openapi_value.valuefrom isa Absent || (_openapi_output["valueFrom"] = _encode(_openapi_value.valuefrom)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_output, "encoding IoK8sApiCoreV1EnvVar"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + _openapi_value.valuefrom isa Absent || push!(_openapi_output, "valueFrom" => _openapi_value.valuefrom) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, value) = _decode(IoK8sApiCoreV1ConfigMapEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretEnvSource}, value) = _decode(IoK8sApiCoreV1SecretEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvFromSource + configmapref::Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing} = ABSENT + prefix::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvFromSource}, value) = _decode(IoK8sApiCoreV1EnvFromSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvFromSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvFromSource") + _openapi_field_configmapref = haskey(_openapi_object, "configMapRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing}, _openapi_object["configMapRef"], _openapi_validate) : ABSENT + _openapi_field_prefix = haskey(_openapi_object, "prefix") ? _decode(Union{Absent,Nothing,String}, _openapi_object["prefix"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapRef","prefix","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvFromSource(; configmapref = _openapi_field_configmapref, prefix = _openapi_field_prefix, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapref isa Absent || (_openapi_output["configMapRef"] = _encode(_openapi_value.configmapref)) + _openapi_value.prefix isa Absent || (_openapi_output["prefix"] = _encode(_openapi_value.prefix)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapref isa Absent || push!(_openapi_output, "configMapRef" => _openapi_value.configmapref) + _openapi_value.prefix isa Absent || push!(_openapi_output, "prefix" => _openapi_value.prefix) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ExecAction + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ExecAction}, value) = _decode(IoK8sApiCoreV1ExecAction, value, true) +function _decode(::Type{IoK8sApiCoreV1ExecAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_raw, "decoding IoK8sApiCoreV1ExecAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ExecAction") + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("command",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ExecAction(; command = _openapi_field_command, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_output, "encoding IoK8sApiCoreV1ExecAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPHeader + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPHeader}, value) = _decode(IoK8sApiCoreV1HTTPHeader, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPHeader}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPHeader") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPHeader(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_output, "encoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgUtilIntstrIntOrString + value::Union{Int64,String} +end +_decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value) = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, value, true) +function _decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), value, "decoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(Int64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgUtilIntstrIntOrString")) + return IoK8sApimachineryPkgUtilIntstrIntOrString(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgUtilIntstrIntOrString) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), output, "encoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPGetAction + host::Union{Absent,Nothing,String} = ABSENT + httpheaders::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}} = ABSENT + path::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + scheme::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPGetAction}, value) = _decode(IoK8sApiCoreV1HTTPGetAction, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPGetAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPGetAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_httpheaders = haskey(_openapi_object, "httpHeaders") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}}, _openapi_object["httpHeaders"], _openapi_validate) : ABSENT + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1HTTPGetAction"), _openapi_validate) + _openapi_field_scheme = haskey(_openapi_object, "scheme") ? _decode(Union{Absent,Nothing,String}, _openapi_object["scheme"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","httpHeaders","path","port","scheme") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPGetAction(; host = _openapi_field_host, httpheaders = _openapi_field_httpheaders, path = _openapi_field_path, port = _openapi_field_port, scheme = _openapi_field_scheme, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.httpheaders isa Absent || (_openapi_output["httpHeaders"] = _encode(_openapi_value.httpheaders)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.scheme isa Absent || (_openapi_output["scheme"] = _encode(_openapi_value.scheme)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_output, "encoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.httpheaders isa Absent || push!(_openapi_output, "httpHeaders" => _openapi_value.httpheaders) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.scheme isa Absent || push!(_openapi_output, "scheme" => _openapi_value.scheme) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SleepAction + seconds::Int64 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SleepAction}, value) = _decode(IoK8sApiCoreV1SleepAction, value, true) +function _decode(::Type{IoK8sApiCoreV1SleepAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_raw, "decoding IoK8sApiCoreV1SleepAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SleepAction") + _openapi_field_seconds = _decode(Int64, _required(_openapi_object, "seconds", "IoK8sApiCoreV1SleepAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("seconds",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SleepAction(; seconds = _openapi_field_seconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.seconds isa Absent || (_openapi_output["seconds"] = _encode(_openapi_value.seconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_output, "encoding IoK8sApiCoreV1SleepAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.seconds isa Absent || push!(_openapi_output, "seconds" => _openapi_value.seconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TCPSocketAction + host::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TCPSocketAction}, value) = _decode(IoK8sApiCoreV1TCPSocketAction, value, true) +function _decode(::Type{IoK8sApiCoreV1TCPSocketAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_raw, "decoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TCPSocketAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1TCPSocketAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TCPSocketAction(; host = _openapi_field_host, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_output, "encoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LifecycleHandler + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + sleep::Union{Absent,IoK8sApiCoreV1SleepAction,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LifecycleHandler}, value) = _decode(IoK8sApiCoreV1LifecycleHandler, value, true) +function _decode(::Type{IoK8sApiCoreV1LifecycleHandler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_raw, "decoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LifecycleHandler") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_sleep = haskey(_openapi_object, "sleep") ? _decode(Union{Absent,IoK8sApiCoreV1SleepAction,Nothing}, _openapi_object["sleep"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","httpGet","sleep","tcpSocket") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LifecycleHandler(; exec = _openapi_field_exec, httpget = _openapi_field_httpget, sleep = _openapi_field_sleep, tcpsocket = _openapi_field_tcpsocket, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.sleep isa Absent || (_openapi_output["sleep"] = _encode(_openapi_value.sleep)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_output, "encoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.sleep isa Absent || push!(_openapi_output, "sleep" => _openapi_value.sleep) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Lifecycle + poststart::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + prestop::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + stopsignal::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Lifecycle}, value) = _decode(IoK8sApiCoreV1Lifecycle, value, true) +function _decode(::Type{IoK8sApiCoreV1Lifecycle}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_raw, "decoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Lifecycle") + _openapi_field_poststart = haskey(_openapi_object, "postStart") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["postStart"], _openapi_validate) : ABSENT + _openapi_field_prestop = haskey(_openapi_object, "preStop") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["preStop"], _openapi_validate) : ABSENT + _openapi_field_stopsignal = haskey(_openapi_object, "stopSignal") ? _decode(Union{Absent,Nothing,String}, _openapi_object["stopSignal"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("postStart","preStop","stopSignal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Lifecycle(; poststart = _openapi_field_poststart, prestop = _openapi_field_prestop, stopsignal = _openapi_field_stopsignal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.poststart isa Absent || (_openapi_output["postStart"] = _encode(_openapi_value.poststart)) + _openapi_value.prestop isa Absent || (_openapi_output["preStop"] = _encode(_openapi_value.prestop)) + _openapi_value.stopsignal isa Absent || (_openapi_output["stopSignal"] = _encode(_openapi_value.stopsignal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_output, "encoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = Pair{String,Any}[] + _openapi_value.poststart isa Absent || push!(_openapi_output, "postStart" => _openapi_value.poststart) + _openapi_value.prestop isa Absent || push!(_openapi_output, "preStop" => _openapi_value.prestop) + _openapi_value.stopsignal isa Absent || push!(_openapi_output, "stopSignal" => _openapi_value.stopsignal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GRPCAction + port::Int32 + service::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GRPCAction}, value) = _decode(IoK8sApiCoreV1GRPCAction, value, true) +function _decode(::Type{IoK8sApiCoreV1GRPCAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_raw, "decoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GRPCAction") + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1GRPCAction"), _openapi_validate) + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,Nothing,String}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("port","service") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GRPCAction(; port = _openapi_field_port, service = _openapi_field_service, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_output, "encoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Probe + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + failurethreshold::Union{Absent,Int32,Nothing} = ABSENT + grpc::Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + initialdelayseconds::Union{Absent,Int32,Nothing} = ABSENT + periodseconds::Union{Absent,Int32,Nothing} = ABSENT + successthreshold::Union{Absent,Int32,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + timeoutseconds::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Probe}, value) = _decode(IoK8sApiCoreV1Probe, value, true) +function _decode(::Type{IoK8sApiCoreV1Probe}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_raw, "decoding IoK8sApiCoreV1Probe"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Probe") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_failurethreshold = haskey(_openapi_object, "failureThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["failureThreshold"], _openapi_validate) : ABSENT + _openapi_field_grpc = haskey(_openapi_object, "grpc") ? _decode(Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing}, _openapi_object["grpc"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_initialdelayseconds = haskey(_openapi_object, "initialDelaySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["initialDelaySeconds"], _openapi_validate) : ABSENT + _openapi_field_periodseconds = haskey(_openapi_object, "periodSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["periodSeconds"], _openapi_validate) : ABSENT + _openapi_field_successthreshold = haskey(_openapi_object, "successThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["successThreshold"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_timeoutseconds = haskey(_openapi_object, "timeoutSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["timeoutSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","failureThreshold","grpc","httpGet","initialDelaySeconds","periodSeconds","successThreshold","tcpSocket","terminationGracePeriodSeconds","timeoutSeconds") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Probe(; exec = _openapi_field_exec, failurethreshold = _openapi_field_failurethreshold, grpc = _openapi_field_grpc, httpget = _openapi_field_httpget, initialdelayseconds = _openapi_field_initialdelayseconds, periodseconds = _openapi_field_periodseconds, successthreshold = _openapi_field_successthreshold, tcpsocket = _openapi_field_tcpsocket, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, timeoutseconds = _openapi_field_timeoutseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.failurethreshold isa Absent || (_openapi_output["failureThreshold"] = _encode(_openapi_value.failurethreshold)) + _openapi_value.grpc isa Absent || (_openapi_output["grpc"] = _encode(_openapi_value.grpc)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.initialdelayseconds isa Absent || (_openapi_output["initialDelaySeconds"] = _encode(_openapi_value.initialdelayseconds)) + _openapi_value.periodseconds isa Absent || (_openapi_output["periodSeconds"] = _encode(_openapi_value.periodseconds)) + _openapi_value.successthreshold isa Absent || (_openapi_output["successThreshold"] = _encode(_openapi_value.successthreshold)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.timeoutseconds isa Absent || (_openapi_output["timeoutSeconds"] = _encode(_openapi_value.timeoutseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_output, "encoding IoK8sApiCoreV1Probe"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.failurethreshold isa Absent || push!(_openapi_output, "failureThreshold" => _openapi_value.failurethreshold) + _openapi_value.grpc isa Absent || push!(_openapi_output, "grpc" => _openapi_value.grpc) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.initialdelayseconds isa Absent || push!(_openapi_output, "initialDelaySeconds" => _openapi_value.initialdelayseconds) + _openapi_value.periodseconds isa Absent || push!(_openapi_output, "periodSeconds" => _openapi_value.periodseconds) + _openapi_value.successthreshold isa Absent || push!(_openapi_output, "successThreshold" => _openapi_value.successthreshold) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.timeoutseconds isa Absent || push!(_openapi_output, "timeoutSeconds" => _openapi_value.timeoutseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerPort + containerport::Int32 + hostip::Union{Absent,Nothing,String} = ABSENT + hostport::Union{Absent,Int32,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerPort}, value) = _decode(IoK8sApiCoreV1ContainerPort, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerPort") + _openapi_field_containerport = _decode(Int32, _required(_openapi_object, "containerPort", "IoK8sApiCoreV1ContainerPort"), _openapi_validate) + _openapi_field_hostip = haskey(_openapi_object, "hostIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostIP"], _openapi_validate) : ABSENT + _openapi_field_hostport = haskey(_openapi_object, "hostPort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["hostPort"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerPort","hostIP","hostPort","name","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerPort(; containerport = _openapi_field_containerport, hostip = _openapi_field_hostip, hostport = _openapi_field_hostport, name = _openapi_field_name, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerport isa Absent || (_openapi_output["containerPort"] = _encode(_openapi_value.containerport)) + _openapi_value.hostip isa Absent || (_openapi_output["hostIP"] = _encode(_openapi_value.hostip)) + _openapi_value.hostport isa Absent || (_openapi_output["hostPort"] = _encode(_openapi_value.hostport)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_output, "encoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerport isa Absent || push!(_openapi_output, "containerPort" => _openapi_value.containerport) + _openapi_value.hostip isa Absent || push!(_openapi_output, "hostIP" => _openapi_value.hostip) + _openapi_value.hostport isa Absent || push!(_openapi_output, "hostPort" => _openapi_value.hostport) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerResizePolicy + resourcename::String + restartpolicy::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, value) = _decode(IoK8sApiCoreV1ContainerResizePolicy, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerResizePolicy") + _openapi_field_resourcename = _decode(String, _required(_openapi_object, "resourceName", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_field_restartpolicy = _decode(String, _required(_openapi_object, "restartPolicy", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceName","restartPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerResizePolicy(; resourcename = _openapi_field_resourcename, restartpolicy = _openapi_field_restartpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourcename isa Absent || (_openapi_output["resourceName"] = _encode(_openapi_value.resourcename)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_output, "encoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourcename isa Absent || push!(_openapi_output, "resourceName" => _openapi_value.resourcename) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceClaim + name::String + request::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceClaim}, value) = _decode(IoK8sApiCoreV1ResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ResourceClaim"), _openapi_validate) + _openapi_field_request = haskey(_openapi_object, "request") ? _decode(Union{Absent,Nothing,String}, _openapi_object["request"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","request") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceClaim(; name = _openapi_field_name, request = _openapi_field_request, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.request isa Absent || (_openapi_output["request"] = _encode(_openapi_value.request)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.request isa Absent || push!(_openapi_output, "request" => _openapi_value.request) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirements + claims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}} = ABSENT + limits::Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirements}, value) = _decode(IoK8sApiCoreV1ResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirements") + _openapi_field_claims = haskey(_openapi_object, "claims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}}, _openapi_object["claims"], _openapi_validate) : ABSENT + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claims","limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirements(; claims = _openapi_field_claims, limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claims isa Absent || (_openapi_output["claims"] = _encode(_openapi_value.claims)) + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.claims isa Absent || push!(_openapi_output, "claims" => _openapi_value.claims) + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRuleOnExitCodes + operator::String + values::Union{Absent,Union{Nothing,Vector{Int32}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, value) = _decode(IoK8sApiCoreV1ContainerRestartRuleOnExitCodes, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes") + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{Int32}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRuleOnExitCodes(; operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = Pair{String,Any}[] + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRule + action::String + exitcodes::Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, value) = _decode(IoK8sApiCoreV1ContainerRestartRule, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRule") + _openapi_field_action = _decode(String, _required(_openapi_object, "action", "IoK8sApiCoreV1ContainerRestartRule"), _openapi_validate) + _openapi_field_exitcodes = haskey(_openapi_object, "exitCodes") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing}, _openapi_object["exitCodes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","exitCodes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRule(; action = _openapi_field_action, exitcodes = _openapi_field_exitcodes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.exitcodes isa Absent || (_openapi_output["exitCodes"] = _encode(_openapi_value.exitcodes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.exitcodes isa Absent || push!(_openapi_output, "exitCodes" => _openapi_value.exitcodes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AppArmorProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AppArmorProfile}, value) = _decode(IoK8sApiCoreV1AppArmorProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1AppArmorProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_raw, "decoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AppArmorProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1AppArmorProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AppArmorProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_output, "encoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Capabilities + add::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + drop::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Capabilities}, value) = _decode(IoK8sApiCoreV1Capabilities, value, true) +function _decode(::Type{IoK8sApiCoreV1Capabilities}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_raw, "decoding IoK8sApiCoreV1Capabilities"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Capabilities") + _openapi_field_add = haskey(_openapi_object, "add") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["add"], _openapi_validate) : ABSENT + _openapi_field_drop = haskey(_openapi_object, "drop") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["drop"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("add","drop") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Capabilities(; add = _openapi_field_add, drop = _openapi_field_drop, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.add isa Absent || (_openapi_output["add"] = _encode(_openapi_value.add)) + _openapi_value.drop isa Absent || (_openapi_output["drop"] = _encode(_openapi_value.drop)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_output, "encoding IoK8sApiCoreV1Capabilities"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = Pair{String,Any}[] + _openapi_value.add isa Absent || push!(_openapi_output, "add" => _openapi_value.add) + _openapi_value.drop isa Absent || push!(_openapi_output, "drop" => _openapi_value.drop) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SELinuxOptions + level::Union{Absent,Nothing,String} = ABSENT + role::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SELinuxOptions}, value) = _decode(IoK8sApiCoreV1SELinuxOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1SELinuxOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_raw, "decoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SELinuxOptions") + _openapi_field_level = haskey(_openapi_object, "level") ? _decode(Union{Absent,Nothing,String}, _openapi_object["level"], _openapi_validate) : ABSENT + _openapi_field_role = haskey(_openapi_object, "role") ? _decode(Union{Absent,Nothing,String}, _openapi_object["role"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("level","role","type","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SELinuxOptions(; level = _openapi_field_level, role = _openapi_field_role, type_ = _openapi_field_type_, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.level isa Absent || (_openapi_output["level"] = _encode(_openapi_value.level)) + _openapi_value.role isa Absent || (_openapi_output["role"] = _encode(_openapi_value.role)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_output, "encoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.level isa Absent || push!(_openapi_output, "level" => _openapi_value.level) + _openapi_value.role isa Absent || push!(_openapi_output, "role" => _openapi_value.role) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SeccompProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SeccompProfile}, value) = _decode(IoK8sApiCoreV1SeccompProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1SeccompProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_raw, "decoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SeccompProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1SeccompProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SeccompProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_output, "encoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WindowsSecurityContextOptions + gmsacredentialspec::Union{Absent,Nothing,String} = ABSENT + gmsacredentialspecname::Union{Absent,Nothing,String} = ABSENT + hostprocess::Union{Absent,Bool,Nothing} = ABSENT + runasusername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, value) = _decode(IoK8sApiCoreV1WindowsSecurityContextOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_raw, "decoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WindowsSecurityContextOptions") + _openapi_field_gmsacredentialspec = haskey(_openapi_object, "gmsaCredentialSpec") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpec"], _openapi_validate) : ABSENT + _openapi_field_gmsacredentialspecname = haskey(_openapi_object, "gmsaCredentialSpecName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpecName"], _openapi_validate) : ABSENT + _openapi_field_hostprocess = haskey(_openapi_object, "hostProcess") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostProcess"], _openapi_validate) : ABSENT + _openapi_field_runasusername = haskey(_openapi_object, "runAsUserName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runAsUserName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("gmsaCredentialSpec","gmsaCredentialSpecName","hostProcess","runAsUserName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WindowsSecurityContextOptions(; gmsacredentialspec = _openapi_field_gmsacredentialspec, gmsacredentialspecname = _openapi_field_gmsacredentialspecname, hostprocess = _openapi_field_hostprocess, runasusername = _openapi_field_runasusername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.gmsacredentialspec isa Absent || (_openapi_output["gmsaCredentialSpec"] = _encode(_openapi_value.gmsacredentialspec)) + _openapi_value.gmsacredentialspecname isa Absent || (_openapi_output["gmsaCredentialSpecName"] = _encode(_openapi_value.gmsacredentialspecname)) + _openapi_value.hostprocess isa Absent || (_openapi_output["hostProcess"] = _encode(_openapi_value.hostprocess)) + _openapi_value.runasusername isa Absent || (_openapi_output["runAsUserName"] = _encode(_openapi_value.runasusername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_output, "encoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.gmsacredentialspec isa Absent || push!(_openapi_output, "gmsaCredentialSpec" => _openapi_value.gmsacredentialspec) + _openapi_value.gmsacredentialspecname isa Absent || push!(_openapi_output, "gmsaCredentialSpecName" => _openapi_value.gmsacredentialspecname) + _openapi_value.hostprocess isa Absent || push!(_openapi_output, "hostProcess" => _openapi_value.hostprocess) + _openapi_value.runasusername isa Absent || push!(_openapi_output, "runAsUserName" => _openapi_value.runasusername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecurityContext + allowprivilegeescalation::Union{Absent,Bool,Nothing} = ABSENT + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + capabilities::Union{Absent,IoK8sApiCoreV1Capabilities,Nothing} = ABSENT + privileged::Union{Absent,Bool,Nothing} = ABSENT + procmount::Union{Absent,Nothing,String} = ABSENT + readonlyrootfilesystem::Union{Absent,Bool,Nothing} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecurityContext}, value) = _decode(IoK8sApiCoreV1SecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1SecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecurityContext") + _openapi_field_allowprivilegeescalation = haskey(_openapi_object, "allowPrivilegeEscalation") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["allowPrivilegeEscalation"], _openapi_validate) : ABSENT + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_capabilities = haskey(_openapi_object, "capabilities") ? _decode(Union{Absent,IoK8sApiCoreV1Capabilities,Nothing}, _openapi_object["capabilities"], _openapi_validate) : ABSENT + _openapi_field_privileged = haskey(_openapi_object, "privileged") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["privileged"], _openapi_validate) : ABSENT + _openapi_field_procmount = haskey(_openapi_object, "procMount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["procMount"], _openapi_validate) : ABSENT + _openapi_field_readonlyrootfilesystem = haskey(_openapi_object, "readOnlyRootFilesystem") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnlyRootFilesystem"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allowPrivilegeEscalation","appArmorProfile","capabilities","privileged","procMount","readOnlyRootFilesystem","runAsGroup","runAsNonRoot","runAsUser","seLinuxOptions","seccompProfile","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecurityContext(; allowprivilegeescalation = _openapi_field_allowprivilegeescalation, apparmorprofile = _openapi_field_apparmorprofile, capabilities = _openapi_field_capabilities, privileged = _openapi_field_privileged, procmount = _openapi_field_procmount, readonlyrootfilesystem = _openapi_field_readonlyrootfilesystem, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allowprivilegeescalation isa Absent || (_openapi_output["allowPrivilegeEscalation"] = _encode(_openapi_value.allowprivilegeescalation)) + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.capabilities isa Absent || (_openapi_output["capabilities"] = _encode(_openapi_value.capabilities)) + _openapi_value.privileged isa Absent || (_openapi_output["privileged"] = _encode(_openapi_value.privileged)) + _openapi_value.procmount isa Absent || (_openapi_output["procMount"] = _encode(_openapi_value.procmount)) + _openapi_value.readonlyrootfilesystem isa Absent || (_openapi_output["readOnlyRootFilesystem"] = _encode(_openapi_value.readonlyrootfilesystem)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.allowprivilegeescalation isa Absent || push!(_openapi_output, "allowPrivilegeEscalation" => _openapi_value.allowprivilegeescalation) + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.capabilities isa Absent || push!(_openapi_output, "capabilities" => _openapi_value.capabilities) + _openapi_value.privileged isa Absent || push!(_openapi_output, "privileged" => _openapi_value.privileged) + _openapi_value.procmount isa Absent || push!(_openapi_output, "procMount" => _openapi_value.procmount) + _openapi_value.readonlyrootfilesystem isa Absent || push!(_openapi_output, "readOnlyRootFilesystem" => _openapi_value.readonlyrootfilesystem) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeDevice + devicepath::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeDevice}, value) = _decode(IoK8sApiCoreV1VolumeDevice, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeDevice}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeDevice") + _openapi_field_devicepath = _decode(String, _required(_openapi_object, "devicePath", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("devicePath","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeDevice(; devicepath = _openapi_field_devicepath, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.devicepath isa Absent || (_openapi_output["devicePath"] = _encode(_openapi_value.devicepath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_output, "encoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = Pair{String,Any}[] + _openapi_value.devicepath isa Absent || push!(_openapi_output, "devicePath" => _openapi_value.devicepath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeMount + mountpath::String + mountpropagation::Union{Absent,Nothing,String} = ABSENT + name::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + recursivereadonly::Union{Absent,Nothing,String} = ABSENT + subpath::Union{Absent,Nothing,String} = ABSENT + subpathexpr::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeMount}, value) = _decode(IoK8sApiCoreV1VolumeMount, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeMount}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeMount") + _openapi_field_mountpath = _decode(String, _required(_openapi_object, "mountPath", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_mountpropagation = haskey(_openapi_object, "mountPropagation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["mountPropagation"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_recursivereadonly = haskey(_openapi_object, "recursiveReadOnly") ? _decode(Union{Absent,Nothing,String}, _openapi_object["recursiveReadOnly"], _openapi_validate) : ABSENT + _openapi_field_subpath = haskey(_openapi_object, "subPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPath"], _openapi_validate) : ABSENT + _openapi_field_subpathexpr = haskey(_openapi_object, "subPathExpr") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPathExpr"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("mountPath","mountPropagation","name","readOnly","recursiveReadOnly","subPath","subPathExpr") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeMount(; mountpath = _openapi_field_mountpath, mountpropagation = _openapi_field_mountpropagation, name = _openapi_field_name, readonly = _openapi_field_readonly, recursivereadonly = _openapi_field_recursivereadonly, subpath = _openapi_field_subpath, subpathexpr = _openapi_field_subpathexpr, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.mountpath isa Absent || (_openapi_output["mountPath"] = _encode(_openapi_value.mountpath)) + _openapi_value.mountpropagation isa Absent || (_openapi_output["mountPropagation"] = _encode(_openapi_value.mountpropagation)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.recursivereadonly isa Absent || (_openapi_output["recursiveReadOnly"] = _encode(_openapi_value.recursivereadonly)) + _openapi_value.subpath isa Absent || (_openapi_output["subPath"] = _encode(_openapi_value.subpath)) + _openapi_value.subpathexpr isa Absent || (_openapi_output["subPathExpr"] = _encode(_openapi_value.subpathexpr)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_output, "encoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = Pair{String,Any}[] + _openapi_value.mountpath isa Absent || push!(_openapi_output, "mountPath" => _openapi_value.mountpath) + _openapi_value.mountpropagation isa Absent || push!(_openapi_output, "mountPropagation" => _openapi_value.mountpropagation) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.recursivereadonly isa Absent || push!(_openapi_output, "recursiveReadOnly" => _openapi_value.recursivereadonly) + _openapi_value.subpath isa Absent || push!(_openapi_output, "subPath" => _openapi_value.subpath) + _openapi_value.subpathexpr isa Absent || push!(_openapi_output, "subPathExpr" => _openapi_value.subpathexpr) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Container + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Container}, value) = _decode(IoK8sApiCoreV1Container, value, true) +function _decode(::Type{IoK8sApiCoreV1Container}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_raw, "decoding IoK8sApiCoreV1Container"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Container") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Container"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Container(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_output, "encoding IoK8sApiCoreV1Container"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfigOption + name::Union{Absent,Nothing,String} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, value) = _decode(IoK8sApiCoreV1PodDNSConfigOption, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfigOption") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfigOption(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfig + nameservers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + options::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}} = ABSENT + searches::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfig}, value) = _decode(IoK8sApiCoreV1PodDNSConfig, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfig") + _openapi_field_nameservers = haskey(_openapi_object, "nameservers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["nameservers"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_searches = haskey(_openapi_object, "searches") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["searches"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nameservers","options","searches") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfig(; nameservers = _openapi_field_nameservers, options = _openapi_field_options, searches = _openapi_field_searches, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nameservers isa Absent || (_openapi_output["nameservers"] = _encode(_openapi_value.nameservers)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.searches isa Absent || (_openapi_output["searches"] = _encode(_openapi_value.searches)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.nameservers isa Absent || push!(_openapi_output, "nameservers" => _openapi_value.nameservers) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.searches isa Absent || push!(_openapi_output, "searches" => _openapi_value.searches) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralContainer + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + targetcontainername::Union{Absent,Nothing,String} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralContainer}, value) = _decode(IoK8sApiCoreV1EphemeralContainer, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralContainer}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralContainer") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EphemeralContainer"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_targetcontainername = haskey(_openapi_object, "targetContainerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["targetContainerName"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","targetContainerName","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralContainer(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, targetcontainername = _openapi_field_targetcontainername, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.targetcontainername isa Absent || (_openapi_output["targetContainerName"] = _encode(_openapi_value.targetcontainername)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.targetcontainername isa Absent || push!(_openapi_output, "targetContainerName" => _openapi_value.targetcontainername) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostAlias + hostnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + ip::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostAlias}, value) = _decode(IoK8sApiCoreV1HostAlias, value, true) +function _decode(::Type{IoK8sApiCoreV1HostAlias}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_raw, "decoding IoK8sApiCoreV1HostAlias"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostAlias") + _openapi_field_hostnames = haskey(_openapi_object, "hostnames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["hostnames"], _openapi_validate) : ABSENT + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1HostAlias"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostnames","ip") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostAlias(; hostnames = _openapi_field_hostnames, ip = _openapi_field_ip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostnames isa Absent || (_openapi_output["hostnames"] = _encode(_openapi_value.hostnames)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_output, "encoding IoK8sApiCoreV1HostAlias"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostnames isa Absent || push!(_openapi_output, "hostnames" => _openapi_value.hostnames) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LocalObjectReference + name::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LocalObjectReference}, value) = _decode(IoK8sApiCoreV1LocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1LocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LocalObjectReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LocalObjectReference(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecNodeSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, value) = _decode(IoK8sApiCoreV1PodSpecNodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecNodeSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecNodeSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodOS + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodOS}, value) = _decode(IoK8sApiCoreV1PodOS, value, true) +function _decode(::Type{IoK8sApiCoreV1PodOS}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_raw, "decoding IoK8sApiCoreV1PodOS"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodOS") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodOS"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodOS(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_output, "encoding IoK8sApiCoreV1PodOS"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecOverhead + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, value) = _decode(IoK8sApiCoreV1PodSpecOverhead, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecOverhead") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecOverhead(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodReadinessGate + conditiontype::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodReadinessGate}, value) = _decode(IoK8sApiCoreV1PodReadinessGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodReadinessGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodReadinessGate") + _openapi_field_conditiontype = _decode(String, _required(_openapi_object, "conditionType", "IoK8sApiCoreV1PodReadinessGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditionType",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodReadinessGate(; conditiontype = _openapi_field_conditiontype, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditiontype isa Absent || (_openapi_output["conditionType"] = _encode(_openapi_value.conditiontype)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_output, "encoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditiontype isa Absent || push!(_openapi_output, "conditionType" => _openapi_value.conditiontype) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodResourceClaim + name::String + resourceclaimname::Union{Absent,Nothing,String} = ABSENT + resourceclaimtemplatename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodResourceClaim}, value) = _decode(IoK8sApiCoreV1PodResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1PodResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodResourceClaim"), _openapi_validate) + _openapi_field_resourceclaimname = haskey(_openapi_object, "resourceClaimName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimName"], _openapi_validate) : ABSENT + _openapi_field_resourceclaimtemplatename = haskey(_openapi_object, "resourceClaimTemplateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimTemplateName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","resourceClaimName","resourceClaimTemplateName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodResourceClaim(; name = _openapi_field_name, resourceclaimname = _openapi_field_resourceclaimname, resourceclaimtemplatename = _openapi_field_resourceclaimtemplatename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.resourceclaimname isa Absent || (_openapi_output["resourceClaimName"] = _encode(_openapi_value.resourceclaimname)) + _openapi_value.resourceclaimtemplatename isa Absent || (_openapi_output["resourceClaimTemplateName"] = _encode(_openapi_value.resourceclaimtemplatename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.resourceclaimname isa Absent || push!(_openapi_output, "resourceClaimName" => _openapi_value.resourceclaimname) + _openapi_value.resourceclaimtemplatename isa Absent || push!(_openapi_output, "resourceClaimTemplateName" => _openapi_value.resourceclaimtemplatename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSchedulingGate + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, value) = _decode(IoK8sApiCoreV1PodSchedulingGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSchedulingGate") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodSchedulingGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSchedulingGate(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_output, "encoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Sysctl + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Sysctl}, value) = _decode(IoK8sApiCoreV1Sysctl, value, true) +function _decode(::Type{IoK8sApiCoreV1Sysctl}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_raw, "decoding IoK8sApiCoreV1Sysctl"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Sysctl") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Sysctl(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_output, "encoding IoK8sApiCoreV1Sysctl"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSecurityContext + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + fsgroup::Union{Absent,Int64,Nothing} = ABSENT + fsgroupchangepolicy::Union{Absent,Nothing,String} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxchangepolicy::Union{Absent,Nothing,String} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + supplementalgroups::Union{Absent,Union{Nothing,Vector{Int64}}} = ABSENT + supplementalgroupspolicy::Union{Absent,Nothing,String} = ABSENT + sysctls::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSecurityContext}, value) = _decode(IoK8sApiCoreV1PodSecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSecurityContext") + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_fsgroup = haskey(_openapi_object, "fsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["fsGroup"], _openapi_validate) : ABSENT + _openapi_field_fsgroupchangepolicy = haskey(_openapi_object, "fsGroupChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsGroupChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxchangepolicy = haskey(_openapi_object, "seLinuxChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["seLinuxChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroups = haskey(_openapi_object, "supplementalGroups") ? _decode(Union{Absent,Union{Nothing,Vector{Int64}}}, _openapi_object["supplementalGroups"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroupspolicy = haskey(_openapi_object, "supplementalGroupsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["supplementalGroupsPolicy"], _openapi_validate) : ABSENT + _openapi_field_sysctls = haskey(_openapi_object, "sysctls") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}}, _openapi_object["sysctls"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appArmorProfile","fsGroup","fsGroupChangePolicy","runAsGroup","runAsNonRoot","runAsUser","seLinuxChangePolicy","seLinuxOptions","seccompProfile","supplementalGroups","supplementalGroupsPolicy","sysctls","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSecurityContext(; apparmorprofile = _openapi_field_apparmorprofile, fsgroup = _openapi_field_fsgroup, fsgroupchangepolicy = _openapi_field_fsgroupchangepolicy, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxchangepolicy = _openapi_field_selinuxchangepolicy, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, supplementalgroups = _openapi_field_supplementalgroups, supplementalgroupspolicy = _openapi_field_supplementalgroupspolicy, sysctls = _openapi_field_sysctls, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.fsgroup isa Absent || (_openapi_output["fsGroup"] = _encode(_openapi_value.fsgroup)) + _openapi_value.fsgroupchangepolicy isa Absent || (_openapi_output["fsGroupChangePolicy"] = _encode(_openapi_value.fsgroupchangepolicy)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxchangepolicy isa Absent || (_openapi_output["seLinuxChangePolicy"] = _encode(_openapi_value.selinuxchangepolicy)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.supplementalgroups isa Absent || (_openapi_output["supplementalGroups"] = _encode(_openapi_value.supplementalgroups)) + _openapi_value.supplementalgroupspolicy isa Absent || (_openapi_output["supplementalGroupsPolicy"] = _encode(_openapi_value.supplementalgroupspolicy)) + _openapi_value.sysctls isa Absent || (_openapi_output["sysctls"] = _encode(_openapi_value.sysctls)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.fsgroup isa Absent || push!(_openapi_output, "fsGroup" => _openapi_value.fsgroup) + _openapi_value.fsgroupchangepolicy isa Absent || push!(_openapi_output, "fsGroupChangePolicy" => _openapi_value.fsgroupchangepolicy) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxchangepolicy isa Absent || push!(_openapi_output, "seLinuxChangePolicy" => _openapi_value.selinuxchangepolicy) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.supplementalgroups isa Absent || push!(_openapi_output, "supplementalGroups" => _openapi_value.supplementalgroups) + _openapi_value.supplementalgroupspolicy isa Absent || push!(_openapi_output, "supplementalGroupsPolicy" => _openapi_value.supplementalgroupspolicy) + _openapi_value.sysctls isa Absent || push!(_openapi_output, "sysctls" => _openapi_value.sysctls) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Toleration + effect::Union{Absent,Nothing,String} = ABSENT + key::Union{Absent,Nothing,String} = ABSENT + operator::Union{Absent,Nothing,String} = ABSENT + tolerationseconds::Union{Absent,Int64,Nothing} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Toleration}, value) = _decode(IoK8sApiCoreV1Toleration, value, true) +function _decode(::Type{IoK8sApiCoreV1Toleration}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_raw, "decoding IoK8sApiCoreV1Toleration"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Toleration") + _openapi_field_effect = haskey(_openapi_object, "effect") ? _decode(Union{Absent,Nothing,String}, _openapi_object["effect"], _openapi_validate) : ABSENT + _openapi_field_key = haskey(_openapi_object, "key") ? _decode(Union{Absent,Nothing,String}, _openapi_object["key"], _openapi_validate) : ABSENT + _openapi_field_operator = haskey(_openapi_object, "operator") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operator"], _openapi_validate) : ABSENT + _openapi_field_tolerationseconds = haskey(_openapi_object, "tolerationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["tolerationSeconds"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("effect","key","operator","tolerationSeconds","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Toleration(; effect = _openapi_field_effect, key = _openapi_field_key, operator = _openapi_field_operator, tolerationseconds = _openapi_field_tolerationseconds, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.effect isa Absent || (_openapi_output["effect"] = _encode(_openapi_value.effect)) + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.tolerationseconds isa Absent || (_openapi_output["tolerationSeconds"] = _encode(_openapi_value.tolerationseconds)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_output, "encoding IoK8sApiCoreV1Toleration"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = Pair{String,Any}[] + _openapi_value.effect isa Absent || push!(_openapi_output, "effect" => _openapi_value.effect) + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.tolerationseconds isa Absent || push!(_openapi_output, "tolerationSeconds" => _openapi_value.tolerationseconds) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TopologySpreadConstraint + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + maxskew::Int32 + mindomains::Union{Absent,Int32,Nothing} = ABSENT + nodeaffinitypolicy::Union{Absent,Nothing,String} = ABSENT + nodetaintspolicy::Union{Absent,Nothing,String} = ABSENT + topologykey::String + whenunsatisfiable::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, value) = _decode(IoK8sApiCoreV1TopologySpreadConstraint, value, true) +function _decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_raw, "decoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TopologySpreadConstraint") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_maxskew = _decode(Int32, _required(_openapi_object, "maxSkew", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_mindomains = haskey(_openapi_object, "minDomains") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minDomains"], _openapi_validate) : ABSENT + _openapi_field_nodeaffinitypolicy = haskey(_openapi_object, "nodeAffinityPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeAffinityPolicy"], _openapi_validate) : ABSENT + _openapi_field_nodetaintspolicy = haskey(_openapi_object, "nodeTaintsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeTaintsPolicy"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_whenunsatisfiable = _decode(String, _required(_openapi_object, "whenUnsatisfiable", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","maxSkew","minDomains","nodeAffinityPolicy","nodeTaintsPolicy","topologyKey","whenUnsatisfiable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TopologySpreadConstraint(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, maxskew = _openapi_field_maxskew, mindomains = _openapi_field_mindomains, nodeaffinitypolicy = _openapi_field_nodeaffinitypolicy, nodetaintspolicy = _openapi_field_nodetaintspolicy, topologykey = _openapi_field_topologykey, whenunsatisfiable = _openapi_field_whenunsatisfiable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.maxskew isa Absent || (_openapi_output["maxSkew"] = _encode(_openapi_value.maxskew)) + _openapi_value.mindomains isa Absent || (_openapi_output["minDomains"] = _encode(_openapi_value.mindomains)) + _openapi_value.nodeaffinitypolicy isa Absent || (_openapi_output["nodeAffinityPolicy"] = _encode(_openapi_value.nodeaffinitypolicy)) + _openapi_value.nodetaintspolicy isa Absent || (_openapi_output["nodeTaintsPolicy"] = _encode(_openapi_value.nodetaintspolicy)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + _openapi_value.whenunsatisfiable isa Absent || (_openapi_output["whenUnsatisfiable"] = _encode(_openapi_value.whenunsatisfiable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_output, "encoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.maxskew isa Absent || push!(_openapi_output, "maxSkew" => _openapi_value.maxskew) + _openapi_value.mindomains isa Absent || push!(_openapi_output, "minDomains" => _openapi_value.mindomains) + _openapi_value.nodeaffinitypolicy isa Absent || push!(_openapi_output, "nodeAffinityPolicy" => _openapi_value.nodeaffinitypolicy) + _openapi_value.nodetaintspolicy isa Absent || push!(_openapi_output, "nodeTaintsPolicy" => _openapi_value.nodetaintspolicy) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + _openapi_value.whenunsatisfiable isa Absent || push!(_openapi_output, "whenUnsatisfiable" => _openapi_value.whenunsatisfiable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, value) = _decode(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureDiskVolumeSource + cachingmode::Union{Absent,Nothing,String} = ABSENT + diskname::String + diskuri::String + fstype::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureDiskVolumeSource") + _openapi_field_cachingmode = haskey(_openapi_object, "cachingMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["cachingMode"], _openapi_validate) : ABSENT + _openapi_field_diskname = _decode(String, _required(_openapi_object, "diskName", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_diskuri = _decode(String, _required(_openapi_object, "diskURI", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cachingMode","diskName","diskURI","fsType","kind","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureDiskVolumeSource(; cachingmode = _openapi_field_cachingmode, diskname = _openapi_field_diskname, diskuri = _openapi_field_diskuri, fstype = _openapi_field_fstype, kind = _openapi_field_kind, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cachingmode isa Absent || (_openapi_output["cachingMode"] = _encode(_openapi_value.cachingmode)) + _openapi_value.diskname isa Absent || (_openapi_output["diskName"] = _encode(_openapi_value.diskname)) + _openapi_value.diskuri isa Absent || (_openapi_output["diskURI"] = _encode(_openapi_value.diskuri)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.cachingmode isa Absent || push!(_openapi_output, "cachingMode" => _openapi_value.cachingmode) + _openapi_value.diskname isa Absent || push!(_openapi_output, "diskName" => _openapi_value.diskname) + _openapi_value.diskuri isa Absent || push!(_openapi_output, "diskURI" => _openapi_value.diskuri) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureFileVolumeSource + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretname::String + sharename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureFileVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureFileVolumeSource") + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretname = _decode(String, _required(_openapi_object, "secretName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_field_sharename = _decode(String, _required(_openapi_object, "shareName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("readOnly","secretName","shareName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureFileVolumeSource(; readonly = _openapi_field_readonly, secretname = _openapi_field_secretname, sharename = _openapi_field_sharename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + _openapi_value.sharename isa Absent || (_openapi_output["shareName"] = _encode(_openapi_value.sharename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + _openapi_value.sharename isa Absent || push!(_openapi_output, "shareName" => _openapi_value.sharename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CephFSVolumeSource + monitors::Union{Nothing,Vector{String}} + path::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretfile::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, value) = _decode(IoK8sApiCoreV1CephFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CephFSVolumeSource") + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1CephFSVolumeSource"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretfile = haskey(_openapi_object, "secretFile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretFile"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("monitors","path","readOnly","secretFile","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CephFSVolumeSource(; monitors = _openapi_field_monitors, path = _openapi_field_path, readonly = _openapi_field_readonly, secretfile = _openapi_field_secretfile, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretfile isa Absent || (_openapi_output["secretFile"] = _encode(_openapi_value.secretfile)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretfile isa Absent || push!(_openapi_output, "secretFile" => _openapi_value.secretfile) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CinderVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, value) = _decode(IoK8sApiCoreV1CinderVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CinderVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1CinderVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CinderVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1KeyToPath + key::String + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1KeyToPath}, value) = _decode(IoK8sApiCoreV1KeyToPath, value, true) +function _decode(::Type{IoK8sApiCoreV1KeyToPath}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_raw, "decoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1KeyToPath") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","mode","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1KeyToPath(; key = _openapi_field_key, mode = _openapi_field_mode, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_output, "encoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, value) = _decode(IoK8sApiCoreV1ConfigMapVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, value) = _decode(IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + nodepublishsecretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeattributes::Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, value) = _decode(IoK8sApiCoreV1CSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1CSIVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_nodepublishsecretref = haskey(_openapi_object, "nodePublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["nodePublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeattributes = haskey(_openapi_object, "volumeAttributes") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing}, _openapi_object["volumeAttributes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","nodePublishSecretRef","readOnly","volumeAttributes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, nodepublishsecretref = _openapi_field_nodepublishsecretref, readonly = _openapi_field_readonly, volumeattributes = _openapi_field_volumeattributes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.nodepublishsecretref isa Absent || (_openapi_output["nodePublishSecretRef"] = _encode(_openapi_value.nodepublishsecretref)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeattributes isa Absent || (_openapi_output["volumeAttributes"] = _encode(_openapi_value.volumeattributes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.nodepublishsecretref isa Absent || push!(_openapi_output, "nodePublishSecretRef" => _openapi_value.nodepublishsecretref) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeattributes isa Absent || push!(_openapi_output, "volumeAttributes" => _openapi_value.volumeattributes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeFile + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeFile, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeFile") + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1DownwardAPIVolumeFile"), _openapi_validate) + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fieldRef","mode","path","resourceFieldRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeFile(; fieldref = _openapi_field_fieldref, mode = _openapi_field_mode, path = _openapi_field_path, resourcefieldref = _openapi_field_resourcefieldref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = Pair{String,Any}[] + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EmptyDirVolumeSource + medium::Union{Absent,Nothing,String} = ABSENT + sizelimit::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, value) = _decode(IoK8sApiCoreV1EmptyDirVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EmptyDirVolumeSource") + _openapi_field_medium = haskey(_openapi_object, "medium") ? _decode(Union{Absent,Nothing,String}, _openapi_object["medium"], _openapi_validate) : ABSENT + _openapi_field_sizelimit = haskey(_openapi_object, "sizeLimit") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["sizeLimit"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("medium","sizeLimit") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EmptyDirVolumeSource(; medium = _openapi_field_medium, sizelimit = _openapi_field_sizelimit, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.medium isa Absent || (_openapi_output["medium"] = _encode(_openapi_value.medium)) + _openapi_value.sizelimit isa Absent || (_openapi_output["sizeLimit"] = _encode(_openapi_value.sizelimit)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.medium isa Absent || push!(_openapi_output, "medium" => _openapi_value.medium) + _openapi_value.sizelimit isa Absent || push!(_openapi_output, "sizeLimit" => _openapi_value.sizelimit) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedLocalObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, value) = _decode(IoK8sApiCoreV1TypedLocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedLocalObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedLocalObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedObjectReference}, value) = _decode(IoK8sApiCoreV1TypedObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirements + limits::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirements") + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirements(; limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimSpec + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + datasource::Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing} = ABSENT + datasourceref::Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing} = ABSENT + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + storageclassname::Union{Absent,Nothing,String} = ABSENT + volumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + volumemode::Union{Absent,Nothing,String} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimSpec") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_datasource = haskey(_openapi_object, "dataSource") ? _decode(Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing}, _openapi_object["dataSource"], _openapi_validate) : ABSENT + _openapi_field_datasourceref = haskey(_openapi_object, "dataSourceRef") ? _decode(Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing}, _openapi_object["dataSourceRef"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = haskey(_openapi_object, "storageClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageClassName"], _openapi_validate) : ABSENT + _openapi_field_volumeattributesclassname = haskey(_openapi_object, "volumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_volumemode = haskey(_openapi_object, "volumeMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeMode"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","dataSource","dataSourceRef","resources","selector","storageClassName","volumeAttributesClassName","volumeMode","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimSpec(; accessmodes = _openapi_field_accessmodes, datasource = _openapi_field_datasource, datasourceref = _openapi_field_datasourceref, resources = _openapi_field_resources, selector = _openapi_field_selector, storageclassname = _openapi_field_storageclassname, volumeattributesclassname = _openapi_field_volumeattributesclassname, volumemode = _openapi_field_volumemode, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.datasource isa Absent || (_openapi_output["dataSource"] = _encode(_openapi_value.datasource)) + _openapi_value.datasourceref isa Absent || (_openapi_output["dataSourceRef"] = _encode(_openapi_value.datasourceref)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + _openapi_value.volumeattributesclassname isa Absent || (_openapi_output["volumeAttributesClassName"] = _encode(_openapi_value.volumeattributesclassname)) + _openapi_value.volumemode isa Absent || (_openapi_output["volumeMode"] = _encode(_openapi_value.volumemode)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.datasource isa Absent || push!(_openapi_output, "dataSource" => _openapi_value.datasource) + _openapi_value.datasourceref isa Absent || push!(_openapi_output, "dataSourceRef" => _openapi_value.datasourceref) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + _openapi_value.volumeattributesclassname isa Absent || push!(_openapi_output, "volumeAttributesClassName" => _openapi_value.volumeattributesclassname) + _openapi_value.volumemode isa Absent || push!(_openapi_output, "volumeMode" => _openapi_value.volumemode) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimTemplate + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiCoreV1PersistentVolumeClaimSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimTemplate, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimTemplate") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, _required(_openapi_object, "spec", "IoK8sApiCoreV1PersistentVolumeClaimTemplate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimTemplate(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralVolumeSource + volumeclaimtemplate::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, value) = _decode(IoK8sApiCoreV1EphemeralVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralVolumeSource") + _openapi_field_volumeclaimtemplate = haskey(_openapi_object, "volumeClaimTemplate") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing}, _openapi_object["volumeClaimTemplate"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("volumeClaimTemplate",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralVolumeSource(; volumeclaimtemplate = _openapi_field_volumeclaimtemplate, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.volumeclaimtemplate isa Absent || (_openapi_output["volumeClaimTemplate"] = _encode(_openapi_value.volumeclaimtemplate)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.volumeclaimtemplate isa Absent || push!(_openapi_output, "volumeClaimTemplate" => _openapi_value.volumeclaimtemplate) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FCVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + lun::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + targetwwns::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + wwids::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FCVolumeSource}, value) = _decode(IoK8sApiCoreV1FCVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FCVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FCVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_lun = haskey(_openapi_object, "lun") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["lun"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_targetwwns = haskey(_openapi_object, "targetWWNs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["targetWWNs"], _openapi_validate) : ABSENT + _openapi_field_wwids = haskey(_openapi_object, "wwids") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["wwids"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","lun","readOnly","targetWWNs","wwids") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FCVolumeSource(; fstype = _openapi_field_fstype, lun = _openapi_field_lun, readonly = _openapi_field_readonly, targetwwns = _openapi_field_targetwwns, wwids = _openapi_field_wwids, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.targetwwns isa Absent || (_openapi_output["targetWWNs"] = _encode(_openapi_value.targetwwns)) + _openapi_value.wwids isa Absent || (_openapi_output["wwids"] = _encode(_openapi_value.wwids)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.targetwwns isa Absent || push!(_openapi_output, "targetWWNs" => _openapi_value.targetwwns) + _openapi_value.wwids isa Absent || push!(_openapi_output, "wwids" => _openapi_value.wwids) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSourceOptions + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, value) = _decode(IoK8sApiCoreV1FlexVolumeSourceOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSourceOptions") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSourceOptions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + options::Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, value) = _decode(IoK8sApiCoreV1FlexVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1FlexVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","options","readOnly","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, options = _openapi_field_options, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlockerVolumeSource + datasetname::Union{Absent,Nothing,String} = ABSENT + datasetuuid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, value) = _decode(IoK8sApiCoreV1FlockerVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlockerVolumeSource") + _openapi_field_datasetname = haskey(_openapi_object, "datasetName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetName"], _openapi_validate) : ABSENT + _openapi_field_datasetuuid = haskey(_openapi_object, "datasetUUID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetUUID"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("datasetName","datasetUUID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlockerVolumeSource(; datasetname = _openapi_field_datasetname, datasetuuid = _openapi_field_datasetuuid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.datasetname isa Absent || (_openapi_output["datasetName"] = _encode(_openapi_value.datasetname)) + _openapi_value.datasetuuid isa Absent || (_openapi_output["datasetUUID"] = _encode(_openapi_value.datasetuuid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.datasetname isa Absent || push!(_openapi_output, "datasetName" => _openapi_value.datasetname) + _openapi_value.datasetuuid isa Absent || push!(_openapi_output, "datasetUUID" => _openapi_value.datasetuuid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GCEPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + pdname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GCEPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_pdname = _decode(String, _required(_openapi_object, "pdName", "IoK8sApiCoreV1GCEPersistentDiskVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","pdName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GCEPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, pdname = _openapi_field_pdname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.pdname isa Absent || (_openapi_output["pdName"] = _encode(_openapi_value.pdname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.pdname isa Absent || push!(_openapi_output, "pdName" => _openapi_value.pdname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GitRepoVolumeSource + directory::Union{Absent,Nothing,String} = ABSENT + repository::String + revision::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, value) = _decode(IoK8sApiCoreV1GitRepoVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GitRepoVolumeSource") + _openapi_field_directory = haskey(_openapi_object, "directory") ? _decode(Union{Absent,Nothing,String}, _openapi_object["directory"], _openapi_validate) : ABSENT + _openapi_field_repository = _decode(String, _required(_openapi_object, "repository", "IoK8sApiCoreV1GitRepoVolumeSource"), _openapi_validate) + _openapi_field_revision = haskey(_openapi_object, "revision") ? _decode(Union{Absent,Nothing,String}, _openapi_object["revision"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("directory","repository","revision") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GitRepoVolumeSource(; directory = _openapi_field_directory, repository = _openapi_field_repository, revision = _openapi_field_revision, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.directory isa Absent || (_openapi_output["directory"] = _encode(_openapi_value.directory)) + _openapi_value.repository isa Absent || (_openapi_output["repository"] = _encode(_openapi_value.repository)) + _openapi_value.revision isa Absent || (_openapi_output["revision"] = _encode(_openapi_value.revision)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.directory isa Absent || push!(_openapi_output, "directory" => _openapi_value.directory) + _openapi_value.repository isa Absent || push!(_openapi_output, "repository" => _openapi_value.repository) + _openapi_value.revision isa Absent || push!(_openapi_output, "revision" => _openapi_value.revision) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GlusterfsVolumeSource + endpoints::String + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, value) = _decode(IoK8sApiCoreV1GlusterfsVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GlusterfsVolumeSource") + _openapi_field_endpoints = _decode(String, _required(_openapi_object, "endpoints", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endpoints","path","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GlusterfsVolumeSource(; endpoints = _openapi_field_endpoints, path = _openapi_field_path, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostPathVolumeSource + path::String + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, value) = _decode(IoK8sApiCoreV1HostPathVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostPathVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1HostPathVolumeSource"), _openapi_validate) + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostPathVolumeSource(; path = _openapi_field_path, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ImageVolumeSource + pullpolicy::Union{Absent,Nothing,String} = ABSENT + reference::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, value) = _decode(IoK8sApiCoreV1ImageVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ImageVolumeSource") + _openapi_field_pullpolicy = haskey(_openapi_object, "pullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pullPolicy"], _openapi_validate) : ABSENT + _openapi_field_reference = haskey(_openapi_object, "reference") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reference"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("pullPolicy","reference") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ImageVolumeSource(; pullpolicy = _openapi_field_pullpolicy, reference = _openapi_field_reference, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.pullpolicy isa Absent || (_openapi_output["pullPolicy"] = _encode(_openapi_value.pullpolicy)) + _openapi_value.reference isa Absent || (_openapi_output["reference"] = _encode(_openapi_value.reference)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.pullpolicy isa Absent || push!(_openapi_output, "pullPolicy" => _openapi_value.pullpolicy) + _openapi_value.reference isa Absent || push!(_openapi_output, "reference" => _openapi_value.reference) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ISCSIVolumeSource + chapauthdiscovery::Union{Absent,Bool,Nothing} = ABSENT + chapauthsession::Union{Absent,Bool,Nothing} = ABSENT + fstype::Union{Absent,Nothing,String} = ABSENT + initiatorname::Union{Absent,Nothing,String} = ABSENT + iqn::String + iscsiinterface::Union{Absent,Nothing,String} = ABSENT + lun::Int32 + portals::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + targetportal::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, value) = _decode(IoK8sApiCoreV1ISCSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ISCSIVolumeSource") + _openapi_field_chapauthdiscovery = haskey(_openapi_object, "chapAuthDiscovery") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthDiscovery"], _openapi_validate) : ABSENT + _openapi_field_chapauthsession = haskey(_openapi_object, "chapAuthSession") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthSession"], _openapi_validate) : ABSENT + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_initiatorname = haskey(_openapi_object, "initiatorName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["initiatorName"], _openapi_validate) : ABSENT + _openapi_field_iqn = _decode(String, _required(_openapi_object, "iqn", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_iscsiinterface = haskey(_openapi_object, "iscsiInterface") ? _decode(Union{Absent,Nothing,String}, _openapi_object["iscsiInterface"], _openapi_validate) : ABSENT + _openapi_field_lun = _decode(Int32, _required(_openapi_object, "lun", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_portals = haskey(_openapi_object, "portals") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["portals"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_targetportal = _decode(String, _required(_openapi_object, "targetPortal", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("chapAuthDiscovery","chapAuthSession","fsType","initiatorName","iqn","iscsiInterface","lun","portals","readOnly","secretRef","targetPortal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ISCSIVolumeSource(; chapauthdiscovery = _openapi_field_chapauthdiscovery, chapauthsession = _openapi_field_chapauthsession, fstype = _openapi_field_fstype, initiatorname = _openapi_field_initiatorname, iqn = _openapi_field_iqn, iscsiinterface = _openapi_field_iscsiinterface, lun = _openapi_field_lun, portals = _openapi_field_portals, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, targetportal = _openapi_field_targetportal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.chapauthdiscovery isa Absent || (_openapi_output["chapAuthDiscovery"] = _encode(_openapi_value.chapauthdiscovery)) + _openapi_value.chapauthsession isa Absent || (_openapi_output["chapAuthSession"] = _encode(_openapi_value.chapauthsession)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.initiatorname isa Absent || (_openapi_output["initiatorName"] = _encode(_openapi_value.initiatorname)) + _openapi_value.iqn isa Absent || (_openapi_output["iqn"] = _encode(_openapi_value.iqn)) + _openapi_value.iscsiinterface isa Absent || (_openapi_output["iscsiInterface"] = _encode(_openapi_value.iscsiinterface)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.portals isa Absent || (_openapi_output["portals"] = _encode(_openapi_value.portals)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.targetportal isa Absent || (_openapi_output["targetPortal"] = _encode(_openapi_value.targetportal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.chapauthdiscovery isa Absent || push!(_openapi_output, "chapAuthDiscovery" => _openapi_value.chapauthdiscovery) + _openapi_value.chapauthsession isa Absent || push!(_openapi_output, "chapAuthSession" => _openapi_value.chapauthsession) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.initiatorname isa Absent || push!(_openapi_output, "initiatorName" => _openapi_value.initiatorname) + _openapi_value.iqn isa Absent || push!(_openapi_output, "iqn" => _openapi_value.iqn) + _openapi_value.iscsiinterface isa Absent || push!(_openapi_output, "iscsiInterface" => _openapi_value.iscsiinterface) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.portals isa Absent || push!(_openapi_output, "portals" => _openapi_value.portals) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.targetportal isa Absent || push!(_openapi_output, "targetPortal" => _openapi_value.targetportal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NFSVolumeSource + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + server::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, value) = _decode(IoK8sApiCoreV1NFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NFSVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_server = _decode(String, _required(_openapi_object, "server", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","readOnly","server") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NFSVolumeSource(; path = _openapi_field_path, readonly = _openapi_field_readonly, server = _openapi_field_server, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.server isa Absent || (_openapi_output["server"] = _encode(_openapi_value.server)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.server isa Absent || push!(_openapi_output, "server" => _openapi_value.server) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimVolumeSource + claimname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource") + _openapi_field_claimname = _decode(String, _required(_openapi_object, "claimName", "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claimName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimVolumeSource(; claimname = _openapi_field_claimname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claimname isa Absent || (_openapi_output["claimName"] = _encode(_openapi_value.claimname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.claimname isa Absent || push!(_openapi_output, "claimName" => _openapi_value.claimname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PhotonPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + pdid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_pdid = _decode(String, _required(_openapi_object, "pdID", "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","pdID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, pdid = _openapi_field_pdid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.pdid isa Absent || (_openapi_output["pdID"] = _encode(_openapi_value.pdid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.pdid isa Absent || push!(_openapi_output, "pdID" => _openapi_value.pdid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PortworxVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, value) = _decode(IoK8sApiCoreV1PortworxVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PortworxVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1PortworxVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PortworxVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ClusterTrustBundleProjection + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + signername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, value) = _decode(IoK8sApiCoreV1ClusterTrustBundleProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ClusterTrustBundleProjection") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ClusterTrustBundleProjection"), _openapi_validate) + _openapi_field_signername = haskey(_openapi_object, "signerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["signerName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","name","optional","path","signerName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ClusterTrustBundleProjection(; labelselector = _openapi_field_labelselector, name = _openapi_field_name, optional = _openapi_field_optional, path = _openapi_field_path, signername = _openapi_field_signername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_output, "encoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, value) = _decode(IoK8sApiCoreV1ConfigMapProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, value) = _decode(IoK8sApiCoreV1DownwardAPIProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIProjection(; items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjectionUserAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, value) = _decode(IoK8sApiCoreV1PodCertificateProjectionUserAnnotations, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjectionUserAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjectionUserAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjection + certificatechainpath::Union{Absent,Nothing,String} = ABSENT + credentialbundlepath::Union{Absent,Nothing,String} = ABSENT + keypath::Union{Absent,Nothing,String} = ABSENT + keytype::String + maxexpirationseconds::Union{Absent,Int32,Nothing} = ABSENT + signername::String + userannotations::Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, value) = _decode(IoK8sApiCoreV1PodCertificateProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjection") + _openapi_field_certificatechainpath = haskey(_openapi_object, "certificateChainPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["certificateChainPath"], _openapi_validate) : ABSENT + _openapi_field_credentialbundlepath = haskey(_openapi_object, "credentialBundlePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["credentialBundlePath"], _openapi_validate) : ABSENT + _openapi_field_keypath = haskey(_openapi_object, "keyPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyPath"], _openapi_validate) : ABSENT + _openapi_field_keytype = _decode(String, _required(_openapi_object, "keyType", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_maxexpirationseconds = haskey(_openapi_object, "maxExpirationSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["maxExpirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_signername = _decode(String, _required(_openapi_object, "signerName", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_userannotations = haskey(_openapi_object, "userAnnotations") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing}, _openapi_object["userAnnotations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("certificateChainPath","credentialBundlePath","keyPath","keyType","maxExpirationSeconds","signerName","userAnnotations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjection(; certificatechainpath = _openapi_field_certificatechainpath, credentialbundlepath = _openapi_field_credentialbundlepath, keypath = _openapi_field_keypath, keytype = _openapi_field_keytype, maxexpirationseconds = _openapi_field_maxexpirationseconds, signername = _openapi_field_signername, userannotations = _openapi_field_userannotations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.certificatechainpath isa Absent || (_openapi_output["certificateChainPath"] = _encode(_openapi_value.certificatechainpath)) + _openapi_value.credentialbundlepath isa Absent || (_openapi_output["credentialBundlePath"] = _encode(_openapi_value.credentialbundlepath)) + _openapi_value.keypath isa Absent || (_openapi_output["keyPath"] = _encode(_openapi_value.keypath)) + _openapi_value.keytype isa Absent || (_openapi_output["keyType"] = _encode(_openapi_value.keytype)) + _openapi_value.maxexpirationseconds isa Absent || (_openapi_output["maxExpirationSeconds"] = _encode(_openapi_value.maxexpirationseconds)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + _openapi_value.userannotations isa Absent || (_openapi_output["userAnnotations"] = _encode(_openapi_value.userannotations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.certificatechainpath isa Absent || push!(_openapi_output, "certificateChainPath" => _openapi_value.certificatechainpath) + _openapi_value.credentialbundlepath isa Absent || push!(_openapi_output, "credentialBundlePath" => _openapi_value.credentialbundlepath) + _openapi_value.keypath isa Absent || push!(_openapi_output, "keyPath" => _openapi_value.keypath) + _openapi_value.keytype isa Absent || push!(_openapi_output, "keyType" => _openapi_value.keytype) + _openapi_value.maxexpirationseconds isa Absent || push!(_openapi_output, "maxExpirationSeconds" => _openapi_value.maxexpirationseconds) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + _openapi_value.userannotations isa Absent || push!(_openapi_output, "userAnnotations" => _openapi_value.userannotations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretProjection}, value) = _decode(IoK8sApiCoreV1SecretProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_raw, "decoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_output, "encoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceAccountTokenProjection + audience::Union{Absent,Nothing,String} = ABSENT + expirationseconds::Union{Absent,Int64,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, value) = _decode(IoK8sApiCoreV1ServiceAccountTokenProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceAccountTokenProjection") + _openapi_field_audience = haskey(_openapi_object, "audience") ? _decode(Union{Absent,Nothing,String}, _openapi_object["audience"], _openapi_validate) : ABSENT + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ServiceAccountTokenProjection"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("audience","expirationSeconds","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceAccountTokenProjection(; audience = _openapi_field_audience, expirationseconds = _openapi_field_expirationseconds, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.audience isa Absent || (_openapi_output["audience"] = _encode(_openapi_value.audience)) + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_output, "encoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.audience isa Absent || push!(_openapi_output, "audience" => _openapi_value.audience) + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeProjection + clustertrustbundle::Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing} = ABSENT + podcertificate::Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing} = ABSENT + serviceaccounttoken::Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeProjection}, value) = _decode(IoK8sApiCoreV1VolumeProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeProjection") + _openapi_field_clustertrustbundle = haskey(_openapi_object, "clusterTrustBundle") ? _decode(Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing}, _openapi_object["clusterTrustBundle"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_podcertificate = haskey(_openapi_object, "podCertificate") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing}, _openapi_object["podCertificate"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_serviceaccounttoken = haskey(_openapi_object, "serviceAccountToken") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing}, _openapi_object["serviceAccountToken"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clusterTrustBundle","configMap","downwardAPI","podCertificate","secret","serviceAccountToken") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeProjection(; clustertrustbundle = _openapi_field_clustertrustbundle, configmap = _openapi_field_configmap, downwardapi = _openapi_field_downwardapi, podcertificate = _openapi_field_podcertificate, secret = _openapi_field_secret, serviceaccounttoken = _openapi_field_serviceaccounttoken, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clustertrustbundle isa Absent || (_openapi_output["clusterTrustBundle"] = _encode(_openapi_value.clustertrustbundle)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.podcertificate isa Absent || (_openapi_output["podCertificate"] = _encode(_openapi_value.podcertificate)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.serviceaccounttoken isa Absent || (_openapi_output["serviceAccountToken"] = _encode(_openapi_value.serviceaccounttoken)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_output, "encoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.clustertrustbundle isa Absent || push!(_openapi_output, "clusterTrustBundle" => _openapi_value.clustertrustbundle) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.podcertificate isa Absent || push!(_openapi_output, "podCertificate" => _openapi_value.podcertificate) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.serviceaccounttoken isa Absent || push!(_openapi_output, "serviceAccountToken" => _openapi_value.serviceaccounttoken) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ProjectedVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + sources::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, value) = _decode(IoK8sApiCoreV1ProjectedVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ProjectedVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_sources = haskey(_openapi_object, "sources") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}}, _openapi_object["sources"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","sources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ProjectedVolumeSource(; defaultmode = _openapi_field_defaultmode, sources = _openapi_field_sources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.sources isa Absent || (_openapi_output["sources"] = _encode(_openapi_value.sources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.sources isa Absent || push!(_openapi_output, "sources" => _openapi_value.sources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1QuobyteVolumeSource + group::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + registry::String + tenant::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + volume::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, value) = _decode(IoK8sApiCoreV1QuobyteVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1QuobyteVolumeSource") + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_registry = _decode(String, _required(_openapi_object, "registry", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_field_tenant = haskey(_openapi_object, "tenant") ? _decode(Union{Absent,Nothing,String}, _openapi_object["tenant"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_field_volume = _decode(String, _required(_openapi_object, "volume", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("group","readOnly","registry","tenant","user","volume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1QuobyteVolumeSource(; group = _openapi_field_group, readonly = _openapi_field_readonly, registry = _openapi_field_registry, tenant = _openapi_field_tenant, user = _openapi_field_user, volume = _openapi_field_volume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.registry isa Absent || (_openapi_output["registry"] = _encode(_openapi_value.registry)) + _openapi_value.tenant isa Absent || (_openapi_output["tenant"] = _encode(_openapi_value.tenant)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + _openapi_value.volume isa Absent || (_openapi_output["volume"] = _encode(_openapi_value.volume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.registry isa Absent || push!(_openapi_output, "registry" => _openapi_value.registry) + _openapi_value.tenant isa Absent || push!(_openapi_output, "tenant" => _openapi_value.tenant) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + _openapi_value.volume isa Absent || push!(_openapi_output, "volume" => _openapi_value.volume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1RBDVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + image::String + keyring::Union{Absent,Nothing,String} = ABSENT + monitors::Union{Nothing,Vector{String}} + pool::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, value) = _decode(IoK8sApiCoreV1RBDVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1RBDVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_keyring = haskey(_openapi_object, "keyring") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyring"], _openapi_validate) : ABSENT + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_pool = haskey(_openapi_object, "pool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pool"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","image","keyring","monitors","pool","readOnly","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1RBDVolumeSource(; fstype = _openapi_field_fstype, image = _openapi_field_image, keyring = _openapi_field_keyring, monitors = _openapi_field_monitors, pool = _openapi_field_pool, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.keyring isa Absent || (_openapi_output["keyring"] = _encode(_openapi_value.keyring)) + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.pool isa Absent || (_openapi_output["pool"] = _encode(_openapi_value.pool)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.keyring isa Absent || push!(_openapi_output, "keyring" => _openapi_value.keyring) + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.pool isa Absent || push!(_openapi_output, "pool" => _openapi_value.pool) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScaleIOVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + gateway::String + protectiondomain::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::IoK8sApiCoreV1LocalObjectReference + sslenabled::Union{Absent,Bool,Nothing} = ABSENT + storagemode::Union{Absent,Nothing,String} = ABSENT + storagepool::Union{Absent,Nothing,String} = ABSENT + system::String + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, value) = _decode(IoK8sApiCoreV1ScaleIOVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScaleIOVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_gateway = _decode(String, _required(_openapi_object, "gateway", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_protectiondomain = haskey(_openapi_object, "protectionDomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protectionDomain"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = _decode(IoK8sApiCoreV1LocalObjectReference, _required(_openapi_object, "secretRef", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_sslenabled = haskey(_openapi_object, "sslEnabled") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["sslEnabled"], _openapi_validate) : ABSENT + _openapi_field_storagemode = haskey(_openapi_object, "storageMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageMode"], _openapi_validate) : ABSENT + _openapi_field_storagepool = haskey(_openapi_object, "storagePool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePool"], _openapi_validate) : ABSENT + _openapi_field_system = _decode(String, _required(_openapi_object, "system", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","gateway","protectionDomain","readOnly","secretRef","sslEnabled","storageMode","storagePool","system","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScaleIOVolumeSource(; fstype = _openapi_field_fstype, gateway = _openapi_field_gateway, protectiondomain = _openapi_field_protectiondomain, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, sslenabled = _openapi_field_sslenabled, storagemode = _openapi_field_storagemode, storagepool = _openapi_field_storagepool, system = _openapi_field_system, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.gateway isa Absent || (_openapi_output["gateway"] = _encode(_openapi_value.gateway)) + _openapi_value.protectiondomain isa Absent || (_openapi_output["protectionDomain"] = _encode(_openapi_value.protectiondomain)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.sslenabled isa Absent || (_openapi_output["sslEnabled"] = _encode(_openapi_value.sslenabled)) + _openapi_value.storagemode isa Absent || (_openapi_output["storageMode"] = _encode(_openapi_value.storagemode)) + _openapi_value.storagepool isa Absent || (_openapi_output["storagePool"] = _encode(_openapi_value.storagepool)) + _openapi_value.system isa Absent || (_openapi_output["system"] = _encode(_openapi_value.system)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.gateway isa Absent || push!(_openapi_output, "gateway" => _openapi_value.gateway) + _openapi_value.protectiondomain isa Absent || push!(_openapi_output, "protectionDomain" => _openapi_value.protectiondomain) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.sslenabled isa Absent || push!(_openapi_output, "sslEnabled" => _openapi_value.sslenabled) + _openapi_value.storagemode isa Absent || push!(_openapi_output, "storageMode" => _openapi_value.storagemode) + _openapi_value.storagepool isa Absent || push!(_openapi_output, "storagePool" => _openapi_value.storagepool) + _openapi_value.system isa Absent || push!(_openapi_output, "system" => _openapi_value.system) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + secretname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, value) = _decode(IoK8sApiCoreV1SecretVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_secretname = haskey(_openapi_object, "secretName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","optional","secretName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, optional = _openapi_field_optional, secretname = _openapi_field_secretname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1StorageOSVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + volumenamespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, value) = _decode(IoK8sApiCoreV1StorageOSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1StorageOSVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_field_volumenamespace = haskey(_openapi_object, "volumeNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeNamespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeName","volumeNamespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1StorageOSVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumename = _openapi_field_volumename, volumenamespace = _openapi_field_volumenamespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + _openapi_value.volumenamespace isa Absent || (_openapi_output["volumeNamespace"] = _encode(_openapi_value.volumenamespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + _openapi_value.volumenamespace isa Absent || push!(_openapi_output, "volumeNamespace" => _openapi_value.volumenamespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VsphereVirtualDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + storagepolicyid::Union{Absent,Nothing,String} = ABSENT + storagepolicyname::Union{Absent,Nothing,String} = ABSENT + volumepath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyid = haskey(_openapi_object, "storagePolicyID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyID"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyname = haskey(_openapi_object, "storagePolicyName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyName"], _openapi_validate) : ABSENT + _openapi_field_volumepath = _decode(String, _required(_openapi_object, "volumePath", "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","storagePolicyID","storagePolicyName","volumePath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(; fstype = _openapi_field_fstype, storagepolicyid = _openapi_field_storagepolicyid, storagepolicyname = _openapi_field_storagepolicyname, volumepath = _openapi_field_volumepath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.storagepolicyid isa Absent || (_openapi_output["storagePolicyID"] = _encode(_openapi_value.storagepolicyid)) + _openapi_value.storagepolicyname isa Absent || (_openapi_output["storagePolicyName"] = _encode(_openapi_value.storagepolicyname)) + _openapi_value.volumepath isa Absent || (_openapi_output["volumePath"] = _encode(_openapi_value.volumepath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.storagepolicyid isa Absent || push!(_openapi_output, "storagePolicyID" => _openapi_value.storagepolicyid) + _openapi_value.storagepolicyname isa Absent || push!(_openapi_output, "storagePolicyName" => _openapi_value.storagepolicyname) + _openapi_value.volumepath isa Absent || push!(_openapi_output, "volumePath" => _openapi_value.volumepath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Volume + awselasticblockstore::Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing} = ABSENT + azuredisk::Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing} = ABSENT + azurefile::Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing} = ABSENT + cephfs::Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing} = ABSENT + cinder::Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing} = ABSENT + csi::Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing} = ABSENT + emptydir::Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing} = ABSENT + ephemeral::Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing} = ABSENT + fc::Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing} = ABSENT + flexvolume::Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing} = ABSENT + flocker::Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing} = ABSENT + gcepersistentdisk::Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing} = ABSENT + gitrepo::Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing} = ABSENT + glusterfs::Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing} = ABSENT + hostpath::Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing} = ABSENT + image::Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing} = ABSENT + iscsi::Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing} = ABSENT + name::String + nfs::Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing} = ABSENT + persistentvolumeclaim::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing} = ABSENT + photonpersistentdisk::Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing} = ABSENT + portworxvolume::Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing} = ABSENT + projected::Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing} = ABSENT + quobyte::Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing} = ABSENT + rbd::Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing} = ABSENT + scaleio::Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing} = ABSENT + storageos::Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing} = ABSENT + vspherevolume::Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Volume}, value) = _decode(IoK8sApiCoreV1Volume, value, true) +function _decode(::Type{IoK8sApiCoreV1Volume}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_raw, "decoding IoK8sApiCoreV1Volume"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Volume") + _openapi_field_awselasticblockstore = haskey(_openapi_object, "awsElasticBlockStore") ? _decode(Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing}, _openapi_object["awsElasticBlockStore"], _openapi_validate) : ABSENT + _openapi_field_azuredisk = haskey(_openapi_object, "azureDisk") ? _decode(Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing}, _openapi_object["azureDisk"], _openapi_validate) : ABSENT + _openapi_field_azurefile = haskey(_openapi_object, "azureFile") ? _decode(Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing}, _openapi_object["azureFile"], _openapi_validate) : ABSENT + _openapi_field_cephfs = haskey(_openapi_object, "cephfs") ? _decode(Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing}, _openapi_object["cephfs"], _openapi_validate) : ABSENT + _openapi_field_cinder = haskey(_openapi_object, "cinder") ? _decode(Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing}, _openapi_object["cinder"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_csi = haskey(_openapi_object, "csi") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing}, _openapi_object["csi"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_emptydir = haskey(_openapi_object, "emptyDir") ? _decode(Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing}, _openapi_object["emptyDir"], _openapi_validate) : ABSENT + _openapi_field_ephemeral = haskey(_openapi_object, "ephemeral") ? _decode(Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing}, _openapi_object["ephemeral"], _openapi_validate) : ABSENT + _openapi_field_fc = haskey(_openapi_object, "fc") ? _decode(Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing}, _openapi_object["fc"], _openapi_validate) : ABSENT + _openapi_field_flexvolume = haskey(_openapi_object, "flexVolume") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing}, _openapi_object["flexVolume"], _openapi_validate) : ABSENT + _openapi_field_flocker = haskey(_openapi_object, "flocker") ? _decode(Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing}, _openapi_object["flocker"], _openapi_validate) : ABSENT + _openapi_field_gcepersistentdisk = haskey(_openapi_object, "gcePersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing}, _openapi_object["gcePersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_gitrepo = haskey(_openapi_object, "gitRepo") ? _decode(Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing}, _openapi_object["gitRepo"], _openapi_validate) : ABSENT + _openapi_field_glusterfs = haskey(_openapi_object, "glusterfs") ? _decode(Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing}, _openapi_object["glusterfs"], _openapi_validate) : ABSENT + _openapi_field_hostpath = haskey(_openapi_object, "hostPath") ? _decode(Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing}, _openapi_object["hostPath"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_iscsi = haskey(_openapi_object, "iscsi") ? _decode(Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing}, _openapi_object["iscsi"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Volume"), _openapi_validate) + _openapi_field_nfs = haskey(_openapi_object, "nfs") ? _decode(Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing}, _openapi_object["nfs"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumeclaim = haskey(_openapi_object, "persistentVolumeClaim") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing}, _openapi_object["persistentVolumeClaim"], _openapi_validate) : ABSENT + _openapi_field_photonpersistentdisk = haskey(_openapi_object, "photonPersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing}, _openapi_object["photonPersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_portworxvolume = haskey(_openapi_object, "portworxVolume") ? _decode(Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing}, _openapi_object["portworxVolume"], _openapi_validate) : ABSENT + _openapi_field_projected = haskey(_openapi_object, "projected") ? _decode(Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing}, _openapi_object["projected"], _openapi_validate) : ABSENT + _openapi_field_quobyte = haskey(_openapi_object, "quobyte") ? _decode(Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing}, _openapi_object["quobyte"], _openapi_validate) : ABSENT + _openapi_field_rbd = haskey(_openapi_object, "rbd") ? _decode(Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing}, _openapi_object["rbd"], _openapi_validate) : ABSENT + _openapi_field_scaleio = haskey(_openapi_object, "scaleIO") ? _decode(Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing}, _openapi_object["scaleIO"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_storageos = haskey(_openapi_object, "storageos") ? _decode(Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing}, _openapi_object["storageos"], _openapi_validate) : ABSENT + _openapi_field_vspherevolume = haskey(_openapi_object, "vsphereVolume") ? _decode(Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing}, _openapi_object["vsphereVolume"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("awsElasticBlockStore","azureDisk","azureFile","cephfs","cinder","configMap","csi","downwardAPI","emptyDir","ephemeral","fc","flexVolume","flocker","gcePersistentDisk","gitRepo","glusterfs","hostPath","image","iscsi","name","nfs","persistentVolumeClaim","photonPersistentDisk","portworxVolume","projected","quobyte","rbd","scaleIO","secret","storageos","vsphereVolume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Volume(; awselasticblockstore = _openapi_field_awselasticblockstore, azuredisk = _openapi_field_azuredisk, azurefile = _openapi_field_azurefile, cephfs = _openapi_field_cephfs, cinder = _openapi_field_cinder, configmap = _openapi_field_configmap, csi = _openapi_field_csi, downwardapi = _openapi_field_downwardapi, emptydir = _openapi_field_emptydir, ephemeral = _openapi_field_ephemeral, fc = _openapi_field_fc, flexvolume = _openapi_field_flexvolume, flocker = _openapi_field_flocker, gcepersistentdisk = _openapi_field_gcepersistentdisk, gitrepo = _openapi_field_gitrepo, glusterfs = _openapi_field_glusterfs, hostpath = _openapi_field_hostpath, image = _openapi_field_image, iscsi = _openapi_field_iscsi, name = _openapi_field_name, nfs = _openapi_field_nfs, persistentvolumeclaim = _openapi_field_persistentvolumeclaim, photonpersistentdisk = _openapi_field_photonpersistentdisk, portworxvolume = _openapi_field_portworxvolume, projected = _openapi_field_projected, quobyte = _openapi_field_quobyte, rbd = _openapi_field_rbd, scaleio = _openapi_field_scaleio, secret = _openapi_field_secret, storageos = _openapi_field_storageos, vspherevolume = _openapi_field_vspherevolume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.awselasticblockstore isa Absent || (_openapi_output["awsElasticBlockStore"] = _encode(_openapi_value.awselasticblockstore)) + _openapi_value.azuredisk isa Absent || (_openapi_output["azureDisk"] = _encode(_openapi_value.azuredisk)) + _openapi_value.azurefile isa Absent || (_openapi_output["azureFile"] = _encode(_openapi_value.azurefile)) + _openapi_value.cephfs isa Absent || (_openapi_output["cephfs"] = _encode(_openapi_value.cephfs)) + _openapi_value.cinder isa Absent || (_openapi_output["cinder"] = _encode(_openapi_value.cinder)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.csi isa Absent || (_openapi_output["csi"] = _encode(_openapi_value.csi)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.emptydir isa Absent || (_openapi_output["emptyDir"] = _encode(_openapi_value.emptydir)) + _openapi_value.ephemeral isa Absent || (_openapi_output["ephemeral"] = _encode(_openapi_value.ephemeral)) + _openapi_value.fc isa Absent || (_openapi_output["fc"] = _encode(_openapi_value.fc)) + _openapi_value.flexvolume isa Absent || (_openapi_output["flexVolume"] = _encode(_openapi_value.flexvolume)) + _openapi_value.flocker isa Absent || (_openapi_output["flocker"] = _encode(_openapi_value.flocker)) + _openapi_value.gcepersistentdisk isa Absent || (_openapi_output["gcePersistentDisk"] = _encode(_openapi_value.gcepersistentdisk)) + _openapi_value.gitrepo isa Absent || (_openapi_output["gitRepo"] = _encode(_openapi_value.gitrepo)) + _openapi_value.glusterfs isa Absent || (_openapi_output["glusterfs"] = _encode(_openapi_value.glusterfs)) + _openapi_value.hostpath isa Absent || (_openapi_output["hostPath"] = _encode(_openapi_value.hostpath)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.iscsi isa Absent || (_openapi_output["iscsi"] = _encode(_openapi_value.iscsi)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.nfs isa Absent || (_openapi_output["nfs"] = _encode(_openapi_value.nfs)) + _openapi_value.persistentvolumeclaim isa Absent || (_openapi_output["persistentVolumeClaim"] = _encode(_openapi_value.persistentvolumeclaim)) + _openapi_value.photonpersistentdisk isa Absent || (_openapi_output["photonPersistentDisk"] = _encode(_openapi_value.photonpersistentdisk)) + _openapi_value.portworxvolume isa Absent || (_openapi_output["portworxVolume"] = _encode(_openapi_value.portworxvolume)) + _openapi_value.projected isa Absent || (_openapi_output["projected"] = _encode(_openapi_value.projected)) + _openapi_value.quobyte isa Absent || (_openapi_output["quobyte"] = _encode(_openapi_value.quobyte)) + _openapi_value.rbd isa Absent || (_openapi_output["rbd"] = _encode(_openapi_value.rbd)) + _openapi_value.scaleio isa Absent || (_openapi_output["scaleIO"] = _encode(_openapi_value.scaleio)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.storageos isa Absent || (_openapi_output["storageos"] = _encode(_openapi_value.storageos)) + _openapi_value.vspherevolume isa Absent || (_openapi_output["vsphereVolume"] = _encode(_openapi_value.vspherevolume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_output, "encoding IoK8sApiCoreV1Volume"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = Pair{String,Any}[] + _openapi_value.awselasticblockstore isa Absent || push!(_openapi_output, "awsElasticBlockStore" => _openapi_value.awselasticblockstore) + _openapi_value.azuredisk isa Absent || push!(_openapi_output, "azureDisk" => _openapi_value.azuredisk) + _openapi_value.azurefile isa Absent || push!(_openapi_output, "azureFile" => _openapi_value.azurefile) + _openapi_value.cephfs isa Absent || push!(_openapi_output, "cephfs" => _openapi_value.cephfs) + _openapi_value.cinder isa Absent || push!(_openapi_output, "cinder" => _openapi_value.cinder) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.csi isa Absent || push!(_openapi_output, "csi" => _openapi_value.csi) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.emptydir isa Absent || push!(_openapi_output, "emptyDir" => _openapi_value.emptydir) + _openapi_value.ephemeral isa Absent || push!(_openapi_output, "ephemeral" => _openapi_value.ephemeral) + _openapi_value.fc isa Absent || push!(_openapi_output, "fc" => _openapi_value.fc) + _openapi_value.flexvolume isa Absent || push!(_openapi_output, "flexVolume" => _openapi_value.flexvolume) + _openapi_value.flocker isa Absent || push!(_openapi_output, "flocker" => _openapi_value.flocker) + _openapi_value.gcepersistentdisk isa Absent || push!(_openapi_output, "gcePersistentDisk" => _openapi_value.gcepersistentdisk) + _openapi_value.gitrepo isa Absent || push!(_openapi_output, "gitRepo" => _openapi_value.gitrepo) + _openapi_value.glusterfs isa Absent || push!(_openapi_output, "glusterfs" => _openapi_value.glusterfs) + _openapi_value.hostpath isa Absent || push!(_openapi_output, "hostPath" => _openapi_value.hostpath) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.iscsi isa Absent || push!(_openapi_output, "iscsi" => _openapi_value.iscsi) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.nfs isa Absent || push!(_openapi_output, "nfs" => _openapi_value.nfs) + _openapi_value.persistentvolumeclaim isa Absent || push!(_openapi_output, "persistentVolumeClaim" => _openapi_value.persistentvolumeclaim) + _openapi_value.photonpersistentdisk isa Absent || push!(_openapi_output, "photonPersistentDisk" => _openapi_value.photonpersistentdisk) + _openapi_value.portworxvolume isa Absent || push!(_openapi_output, "portworxVolume" => _openapi_value.portworxvolume) + _openapi_value.projected isa Absent || push!(_openapi_output, "projected" => _openapi_value.projected) + _openapi_value.quobyte isa Absent || push!(_openapi_output, "quobyte" => _openapi_value.quobyte) + _openapi_value.rbd isa Absent || push!(_openapi_output, "rbd" => _openapi_value.rbd) + _openapi_value.scaleio isa Absent || push!(_openapi_output, "scaleIO" => _openapi_value.scaleio) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.storageos isa Absent || push!(_openapi_output, "storageos" => _openapi_value.storageos) + _openapi_value.vspherevolume isa Absent || push!(_openapi_output, "vsphereVolume" => _openapi_value.vspherevolume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WorkloadReference + name::String + podgroup::String + podgroupreplicakey::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WorkloadReference}, value) = _decode(IoK8sApiCoreV1WorkloadReference, value, true) +function _decode(::Type{IoK8sApiCoreV1WorkloadReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_raw, "decoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WorkloadReference") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroup = _decode(String, _required(_openapi_object, "podGroup", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroupreplicakey = haskey(_openapi_object, "podGroupReplicaKey") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podGroupReplicaKey"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","podGroup","podGroupReplicaKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WorkloadReference(; name = _openapi_field_name, podgroup = _openapi_field_podgroup, podgroupreplicakey = _openapi_field_podgroupreplicakey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.podgroup isa Absent || (_openapi_output["podGroup"] = _encode(_openapi_value.podgroup)) + _openapi_value.podgroupreplicakey isa Absent || (_openapi_output["podGroupReplicaKey"] = _encode(_openapi_value.podgroupreplicakey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_output, "encoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.podgroup isa Absent || push!(_openapi_output, "podGroup" => _openapi_value.podgroup) + _openapi_value.podgroupreplicakey isa Absent || push!(_openapi_output, "podGroupReplicaKey" => _openapi_value.podgroupreplicakey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpec + activedeadlineseconds::Union{Absent,Int64,Nothing} = ABSENT + affinity::Union{Absent,IoK8sApiCoreV1Affinity,Nothing} = ABSENT + automountserviceaccounttoken::Union{Absent,Bool,Nothing} = ABSENT + containers::Union{Nothing,Vector{IoK8sApiCoreV1Container}} + dnsconfig::Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing} = ABSENT + dnspolicy::Union{Absent,Nothing,String} = ABSENT + enableservicelinks::Union{Absent,Bool,Nothing} = ABSENT + ephemeralcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}} = ABSENT + hostaliases::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}} = ABSENT + hostipc::Union{Absent,Bool,Nothing} = ABSENT + hostnetwork::Union{Absent,Bool,Nothing} = ABSENT + hostpid::Union{Absent,Bool,Nothing} = ABSENT + hostusers::Union{Absent,Bool,Nothing} = ABSENT + hostname::Union{Absent,Nothing,String} = ABSENT + hostnameoverride::Union{Absent,Nothing,String} = ABSENT + imagepullsecrets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}} = ABSENT + initcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}} = ABSENT + nodename::Union{Absent,Nothing,String} = ABSENT + nodeselector::Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing} = ABSENT + os::Union{Absent,IoK8sApiCoreV1PodOS,Nothing} = ABSENT + overhead::Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing} = ABSENT + preemptionpolicy::Union{Absent,Nothing,String} = ABSENT + priority::Union{Absent,Int32,Nothing} = ABSENT + priorityclassname::Union{Absent,Nothing,String} = ABSENT + readinessgates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}} = ABSENT + resourceclaims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + runtimeclassname::Union{Absent,Nothing,String} = ABSENT + schedulername::Union{Absent,Nothing,String} = ABSENT + schedulinggates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing} = ABSENT + serviceaccount::Union{Absent,Nothing,String} = ABSENT + serviceaccountname::Union{Absent,Nothing,String} = ABSENT + sethostnameasfqdn::Union{Absent,Bool,Nothing} = ABSENT + shareprocessnamespace::Union{Absent,Bool,Nothing} = ABSENT + subdomain::Union{Absent,Nothing,String} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + tolerations::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}} = ABSENT + topologyspreadconstraints::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}} = ABSENT + volumes::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}} = ABSENT + workloadref::Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSpec}, value) = _decode(IoK8sApiCoreV1PodSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpec") + _openapi_field_activedeadlineseconds = haskey(_openapi_object, "activeDeadlineSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["activeDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_affinity = haskey(_openapi_object, "affinity") ? _decode(Union{Absent,IoK8sApiCoreV1Affinity,Nothing}, _openapi_object["affinity"], _openapi_validate) : ABSENT + _openapi_field_automountserviceaccounttoken = haskey(_openapi_object, "automountServiceAccountToken") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["automountServiceAccountToken"], _openapi_validate) : ABSENT + _openapi_field_containers = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Container}}, _required(_openapi_object, "containers", "IoK8sApiCoreV1PodSpec"), _openapi_validate) + _openapi_field_dnsconfig = haskey(_openapi_object, "dnsConfig") ? _decode(Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing}, _openapi_object["dnsConfig"], _openapi_validate) : ABSENT + _openapi_field_dnspolicy = haskey(_openapi_object, "dnsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["dnsPolicy"], _openapi_validate) : ABSENT + _openapi_field_enableservicelinks = haskey(_openapi_object, "enableServiceLinks") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["enableServiceLinks"], _openapi_validate) : ABSENT + _openapi_field_ephemeralcontainers = haskey(_openapi_object, "ephemeralContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}}, _openapi_object["ephemeralContainers"], _openapi_validate) : ABSENT + _openapi_field_hostaliases = haskey(_openapi_object, "hostAliases") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}}, _openapi_object["hostAliases"], _openapi_validate) : ABSENT + _openapi_field_hostipc = haskey(_openapi_object, "hostIPC") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostIPC"], _openapi_validate) : ABSENT + _openapi_field_hostnetwork = haskey(_openapi_object, "hostNetwork") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostNetwork"], _openapi_validate) : ABSENT + _openapi_field_hostpid = haskey(_openapi_object, "hostPID") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostPID"], _openapi_validate) : ABSENT + _openapi_field_hostusers = haskey(_openapi_object, "hostUsers") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostUsers"], _openapi_validate) : ABSENT + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_hostnameoverride = haskey(_openapi_object, "hostnameOverride") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostnameOverride"], _openapi_validate) : ABSENT + _openapi_field_imagepullsecrets = haskey(_openapi_object, "imagePullSecrets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}}, _openapi_object["imagePullSecrets"], _openapi_validate) : ABSENT + _openapi_field_initcontainers = haskey(_openapi_object, "initContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}}, _openapi_object["initContainers"], _openapi_validate) : ABSENT + _openapi_field_nodename = haskey(_openapi_object, "nodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeName"], _openapi_validate) : ABSENT + _openapi_field_nodeselector = haskey(_openapi_object, "nodeSelector") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing}, _openapi_object["nodeSelector"], _openapi_validate) : ABSENT + _openapi_field_os = haskey(_openapi_object, "os") ? _decode(Union{Absent,IoK8sApiCoreV1PodOS,Nothing}, _openapi_object["os"], _openapi_validate) : ABSENT + _openapi_field_overhead = haskey(_openapi_object, "overhead") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing}, _openapi_object["overhead"], _openapi_validate) : ABSENT + _openapi_field_preemptionpolicy = haskey(_openapi_object, "preemptionPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["preemptionPolicy"], _openapi_validate) : ABSENT + _openapi_field_priority = haskey(_openapi_object, "priority") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["priority"], _openapi_validate) : ABSENT + _openapi_field_priorityclassname = haskey(_openapi_object, "priorityClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["priorityClassName"], _openapi_validate) : ABSENT + _openapi_field_readinessgates = haskey(_openapi_object, "readinessGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}}, _openapi_object["readinessGates"], _openapi_validate) : ABSENT + _openapi_field_resourceclaims = haskey(_openapi_object, "resourceClaims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}}, _openapi_object["resourceClaims"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_runtimeclassname = haskey(_openapi_object, "runtimeClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runtimeClassName"], _openapi_validate) : ABSENT + _openapi_field_schedulername = haskey(_openapi_object, "schedulerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["schedulerName"], _openapi_validate) : ABSENT + _openapi_field_schedulinggates = haskey(_openapi_object, "schedulingGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}}, _openapi_object["schedulingGates"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_serviceaccount = haskey(_openapi_object, "serviceAccount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccount"], _openapi_validate) : ABSENT + _openapi_field_serviceaccountname = haskey(_openapi_object, "serviceAccountName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccountName"], _openapi_validate) : ABSENT + _openapi_field_sethostnameasfqdn = haskey(_openapi_object, "setHostnameAsFQDN") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["setHostnameAsFQDN"], _openapi_validate) : ABSENT + _openapi_field_shareprocessnamespace = haskey(_openapi_object, "shareProcessNamespace") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["shareProcessNamespace"], _openapi_validate) : ABSENT + _openapi_field_subdomain = haskey(_openapi_object, "subdomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subdomain"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_tolerations = haskey(_openapi_object, "tolerations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}}, _openapi_object["tolerations"], _openapi_validate) : ABSENT + _openapi_field_topologyspreadconstraints = haskey(_openapi_object, "topologySpreadConstraints") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}}, _openapi_object["topologySpreadConstraints"], _openapi_validate) : ABSENT + _openapi_field_volumes = haskey(_openapi_object, "volumes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}}, _openapi_object["volumes"], _openapi_validate) : ABSENT + _openapi_field_workloadref = haskey(_openapi_object, "workloadRef") ? _decode(Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing}, _openapi_object["workloadRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("activeDeadlineSeconds","affinity","automountServiceAccountToken","containers","dnsConfig","dnsPolicy","enableServiceLinks","ephemeralContainers","hostAliases","hostIPC","hostNetwork","hostPID","hostUsers","hostname","hostnameOverride","imagePullSecrets","initContainers","nodeName","nodeSelector","os","overhead","preemptionPolicy","priority","priorityClassName","readinessGates","resourceClaims","resources","restartPolicy","runtimeClassName","schedulerName","schedulingGates","securityContext","serviceAccount","serviceAccountName","setHostnameAsFQDN","shareProcessNamespace","subdomain","terminationGracePeriodSeconds","tolerations","topologySpreadConstraints","volumes","workloadRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpec(; activedeadlineseconds = _openapi_field_activedeadlineseconds, affinity = _openapi_field_affinity, automountserviceaccounttoken = _openapi_field_automountserviceaccounttoken, containers = _openapi_field_containers, dnsconfig = _openapi_field_dnsconfig, dnspolicy = _openapi_field_dnspolicy, enableservicelinks = _openapi_field_enableservicelinks, ephemeralcontainers = _openapi_field_ephemeralcontainers, hostaliases = _openapi_field_hostaliases, hostipc = _openapi_field_hostipc, hostnetwork = _openapi_field_hostnetwork, hostpid = _openapi_field_hostpid, hostusers = _openapi_field_hostusers, hostname = _openapi_field_hostname, hostnameoverride = _openapi_field_hostnameoverride, imagepullsecrets = _openapi_field_imagepullsecrets, initcontainers = _openapi_field_initcontainers, nodename = _openapi_field_nodename, nodeselector = _openapi_field_nodeselector, os = _openapi_field_os, overhead = _openapi_field_overhead, preemptionpolicy = _openapi_field_preemptionpolicy, priority = _openapi_field_priority, priorityclassname = _openapi_field_priorityclassname, readinessgates = _openapi_field_readinessgates, resourceclaims = _openapi_field_resourceclaims, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, runtimeclassname = _openapi_field_runtimeclassname, schedulername = _openapi_field_schedulername, schedulinggates = _openapi_field_schedulinggates, securitycontext = _openapi_field_securitycontext, serviceaccount = _openapi_field_serviceaccount, serviceaccountname = _openapi_field_serviceaccountname, sethostnameasfqdn = _openapi_field_sethostnameasfqdn, shareprocessnamespace = _openapi_field_shareprocessnamespace, subdomain = _openapi_field_subdomain, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, tolerations = _openapi_field_tolerations, topologyspreadconstraints = _openapi_field_topologyspreadconstraints, volumes = _openapi_field_volumes, workloadref = _openapi_field_workloadref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.activedeadlineseconds isa Absent || (_openapi_output["activeDeadlineSeconds"] = _encode(_openapi_value.activedeadlineseconds)) + _openapi_value.affinity isa Absent || (_openapi_output["affinity"] = _encode(_openapi_value.affinity)) + _openapi_value.automountserviceaccounttoken isa Absent || (_openapi_output["automountServiceAccountToken"] = _encode(_openapi_value.automountserviceaccounttoken)) + _openapi_value.containers isa Absent || (_openapi_output["containers"] = _encode(_openapi_value.containers)) + _openapi_value.dnsconfig isa Absent || (_openapi_output["dnsConfig"] = _encode(_openapi_value.dnsconfig)) + _openapi_value.dnspolicy isa Absent || (_openapi_output["dnsPolicy"] = _encode(_openapi_value.dnspolicy)) + _openapi_value.enableservicelinks isa Absent || (_openapi_output["enableServiceLinks"] = _encode(_openapi_value.enableservicelinks)) + _openapi_value.ephemeralcontainers isa Absent || (_openapi_output["ephemeralContainers"] = _encode(_openapi_value.ephemeralcontainers)) + _openapi_value.hostaliases isa Absent || (_openapi_output["hostAliases"] = _encode(_openapi_value.hostaliases)) + _openapi_value.hostipc isa Absent || (_openapi_output["hostIPC"] = _encode(_openapi_value.hostipc)) + _openapi_value.hostnetwork isa Absent || (_openapi_output["hostNetwork"] = _encode(_openapi_value.hostnetwork)) + _openapi_value.hostpid isa Absent || (_openapi_output["hostPID"] = _encode(_openapi_value.hostpid)) + _openapi_value.hostusers isa Absent || (_openapi_output["hostUsers"] = _encode(_openapi_value.hostusers)) + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.hostnameoverride isa Absent || (_openapi_output["hostnameOverride"] = _encode(_openapi_value.hostnameoverride)) + _openapi_value.imagepullsecrets isa Absent || (_openapi_output["imagePullSecrets"] = _encode(_openapi_value.imagepullsecrets)) + _openapi_value.initcontainers isa Absent || (_openapi_output["initContainers"] = _encode(_openapi_value.initcontainers)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.nodeselector isa Absent || (_openapi_output["nodeSelector"] = _encode(_openapi_value.nodeselector)) + _openapi_value.os isa Absent || (_openapi_output["os"] = _encode(_openapi_value.os)) + _openapi_value.overhead isa Absent || (_openapi_output["overhead"] = _encode(_openapi_value.overhead)) + _openapi_value.preemptionpolicy isa Absent || (_openapi_output["preemptionPolicy"] = _encode(_openapi_value.preemptionpolicy)) + _openapi_value.priority isa Absent || (_openapi_output["priority"] = _encode(_openapi_value.priority)) + _openapi_value.priorityclassname isa Absent || (_openapi_output["priorityClassName"] = _encode(_openapi_value.priorityclassname)) + _openapi_value.readinessgates isa Absent || (_openapi_output["readinessGates"] = _encode(_openapi_value.readinessgates)) + _openapi_value.resourceclaims isa Absent || (_openapi_output["resourceClaims"] = _encode(_openapi_value.resourceclaims)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.runtimeclassname isa Absent || (_openapi_output["runtimeClassName"] = _encode(_openapi_value.runtimeclassname)) + _openapi_value.schedulername isa Absent || (_openapi_output["schedulerName"] = _encode(_openapi_value.schedulername)) + _openapi_value.schedulinggates isa Absent || (_openapi_output["schedulingGates"] = _encode(_openapi_value.schedulinggates)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.serviceaccount isa Absent || (_openapi_output["serviceAccount"] = _encode(_openapi_value.serviceaccount)) + _openapi_value.serviceaccountname isa Absent || (_openapi_output["serviceAccountName"] = _encode(_openapi_value.serviceaccountname)) + _openapi_value.sethostnameasfqdn isa Absent || (_openapi_output["setHostnameAsFQDN"] = _encode(_openapi_value.sethostnameasfqdn)) + _openapi_value.shareprocessnamespace isa Absent || (_openapi_output["shareProcessNamespace"] = _encode(_openapi_value.shareprocessnamespace)) + _openapi_value.subdomain isa Absent || (_openapi_output["subdomain"] = _encode(_openapi_value.subdomain)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.tolerations isa Absent || (_openapi_output["tolerations"] = _encode(_openapi_value.tolerations)) + _openapi_value.topologyspreadconstraints isa Absent || (_openapi_output["topologySpreadConstraints"] = _encode(_openapi_value.topologyspreadconstraints)) + _openapi_value.volumes isa Absent || (_openapi_output["volumes"] = _encode(_openapi_value.volumes)) + _openapi_value.workloadref isa Absent || (_openapi_output["workloadRef"] = _encode(_openapi_value.workloadref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.activedeadlineseconds isa Absent || push!(_openapi_output, "activeDeadlineSeconds" => _openapi_value.activedeadlineseconds) + _openapi_value.affinity isa Absent || push!(_openapi_output, "affinity" => _openapi_value.affinity) + _openapi_value.automountserviceaccounttoken isa Absent || push!(_openapi_output, "automountServiceAccountToken" => _openapi_value.automountserviceaccounttoken) + _openapi_value.containers isa Absent || push!(_openapi_output, "containers" => _openapi_value.containers) + _openapi_value.dnsconfig isa Absent || push!(_openapi_output, "dnsConfig" => _openapi_value.dnsconfig) + _openapi_value.dnspolicy isa Absent || push!(_openapi_output, "dnsPolicy" => _openapi_value.dnspolicy) + _openapi_value.enableservicelinks isa Absent || push!(_openapi_output, "enableServiceLinks" => _openapi_value.enableservicelinks) + _openapi_value.ephemeralcontainers isa Absent || push!(_openapi_output, "ephemeralContainers" => _openapi_value.ephemeralcontainers) + _openapi_value.hostaliases isa Absent || push!(_openapi_output, "hostAliases" => _openapi_value.hostaliases) + _openapi_value.hostipc isa Absent || push!(_openapi_output, "hostIPC" => _openapi_value.hostipc) + _openapi_value.hostnetwork isa Absent || push!(_openapi_output, "hostNetwork" => _openapi_value.hostnetwork) + _openapi_value.hostpid isa Absent || push!(_openapi_output, "hostPID" => _openapi_value.hostpid) + _openapi_value.hostusers isa Absent || push!(_openapi_output, "hostUsers" => _openapi_value.hostusers) + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.hostnameoverride isa Absent || push!(_openapi_output, "hostnameOverride" => _openapi_value.hostnameoverride) + _openapi_value.imagepullsecrets isa Absent || push!(_openapi_output, "imagePullSecrets" => _openapi_value.imagepullsecrets) + _openapi_value.initcontainers isa Absent || push!(_openapi_output, "initContainers" => _openapi_value.initcontainers) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.nodeselector isa Absent || push!(_openapi_output, "nodeSelector" => _openapi_value.nodeselector) + _openapi_value.os isa Absent || push!(_openapi_output, "os" => _openapi_value.os) + _openapi_value.overhead isa Absent || push!(_openapi_output, "overhead" => _openapi_value.overhead) + _openapi_value.preemptionpolicy isa Absent || push!(_openapi_output, "preemptionPolicy" => _openapi_value.preemptionpolicy) + _openapi_value.priority isa Absent || push!(_openapi_output, "priority" => _openapi_value.priority) + _openapi_value.priorityclassname isa Absent || push!(_openapi_output, "priorityClassName" => _openapi_value.priorityclassname) + _openapi_value.readinessgates isa Absent || push!(_openapi_output, "readinessGates" => _openapi_value.readinessgates) + _openapi_value.resourceclaims isa Absent || push!(_openapi_output, "resourceClaims" => _openapi_value.resourceclaims) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.runtimeclassname isa Absent || push!(_openapi_output, "runtimeClassName" => _openapi_value.runtimeclassname) + _openapi_value.schedulername isa Absent || push!(_openapi_output, "schedulerName" => _openapi_value.schedulername) + _openapi_value.schedulinggates isa Absent || push!(_openapi_output, "schedulingGates" => _openapi_value.schedulinggates) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.serviceaccount isa Absent || push!(_openapi_output, "serviceAccount" => _openapi_value.serviceaccount) + _openapi_value.serviceaccountname isa Absent || push!(_openapi_output, "serviceAccountName" => _openapi_value.serviceaccountname) + _openapi_value.sethostnameasfqdn isa Absent || push!(_openapi_output, "setHostnameAsFQDN" => _openapi_value.sethostnameasfqdn) + _openapi_value.shareprocessnamespace isa Absent || push!(_openapi_output, "shareProcessNamespace" => _openapi_value.shareprocessnamespace) + _openapi_value.subdomain isa Absent || push!(_openapi_output, "subdomain" => _openapi_value.subdomain) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.tolerations isa Absent || push!(_openapi_output, "tolerations" => _openapi_value.tolerations) + _openapi_value.topologyspreadconstraints isa Absent || push!(_openapi_output, "topologySpreadConstraints" => _openapi_value.topologyspreadconstraints) + _openapi_value.volumes isa Absent || push!(_openapi_output, "volumes" => _openapi_value.volumes) + _openapi_value.workloadref isa Absent || push!(_openapi_output, "workloadRef" => _openapi_value.workloadref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodTemplateSpec + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PodSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, value) = _decode(IoK8sApiCoreV1PodTemplateSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodTemplateSpec") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodTemplateSpec(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1RollingUpdateDaemonSet + maxsurge::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + maxunavailable::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1RollingUpdateDaemonSet}, value) = _decode(IoK8sApiAppsV1RollingUpdateDaemonSet, value, true) +function _decode(::Type{IoK8sApiAppsV1RollingUpdateDaemonSet}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet"), _openapi_raw, "decoding IoK8sApiAppsV1RollingUpdateDaemonSet"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1RollingUpdateDaemonSet") + _openapi_field_maxsurge = haskey(_openapi_object, "maxSurge") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxSurge"], _openapi_validate) : ABSENT + _openapi_field_maxunavailable = haskey(_openapi_object, "maxUnavailable") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxUnavailable"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("maxSurge","maxUnavailable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1RollingUpdateDaemonSet(; maxsurge = _openapi_field_maxsurge, maxunavailable = _openapi_field_maxunavailable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1RollingUpdateDaemonSet) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.maxsurge isa Absent || (_openapi_output["maxSurge"] = _encode(_openapi_value.maxsurge)) + _openapi_value.maxunavailable isa Absent || (_openapi_output["maxUnavailable"] = _encode(_openapi_value.maxunavailable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDaemonSet"), _openapi_output, "encoding IoK8sApiAppsV1RollingUpdateDaemonSet"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1RollingUpdateDaemonSet) + _openapi_output = Pair{String,Any}[] + _openapi_value.maxsurge isa Absent || push!(_openapi_output, "maxSurge" => _openapi_value.maxsurge) + _openapi_value.maxunavailable isa Absent || push!(_openapi_output, "maxUnavailable" => _openapi_value.maxunavailable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSetUpdateStrategy + rollingupdate::Union{Absent,IoK8sApiAppsV1RollingUpdateDaemonSet,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSetUpdateStrategy}, value) = _decode(IoK8sApiAppsV1DaemonSetUpdateStrategy, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSetUpdateStrategy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSetUpdateStrategy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSetUpdateStrategy") + _openapi_field_rollingupdate = haskey(_openapi_object, "rollingUpdate") ? _decode(Union{Absent,IoK8sApiAppsV1RollingUpdateDaemonSet,Nothing}, _openapi_object["rollingUpdate"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("rollingUpdate","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSetUpdateStrategy(; rollingupdate = _openapi_field_rollingupdate, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSetUpdateStrategy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.rollingupdate isa Absent || (_openapi_output["rollingUpdate"] = _encode(_openapi_value.rollingupdate)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetUpdateStrategy"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSetUpdateStrategy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSetUpdateStrategy) + _openapi_output = Pair{String,Any}[] + _openapi_value.rollingupdate isa Absent || push!(_openapi_output, "rollingUpdate" => _openapi_value.rollingupdate) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSetSpec + minreadyseconds::Union{Absent,Int32,Nothing} = ABSENT + revisionhistorylimit::Union{Absent,Int32,Nothing} = ABSENT + selector::IoK8sApimachineryPkgApisMetaV1LabelSelector + template::IoK8sApiCoreV1PodTemplateSpec + updatestrategy::Union{Absent,IoK8sApiAppsV1DaemonSetUpdateStrategy,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSetSpec}, value) = _decode(IoK8sApiAppsV1DaemonSetSpec, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSetSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSetSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSetSpec") + _openapi_field_minreadyseconds = haskey(_openapi_object, "minReadySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReadySeconds"], _openapi_validate) : ABSENT + _openapi_field_revisionhistorylimit = haskey(_openapi_object, "revisionHistoryLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["revisionHistoryLimit"], _openapi_validate) : ABSENT + _openapi_field_selector = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, _required(_openapi_object, "selector", "IoK8sApiAppsV1DaemonSetSpec"), _openapi_validate) + _openapi_field_template = _decode(IoK8sApiCoreV1PodTemplateSpec, _required(_openapi_object, "template", "IoK8sApiAppsV1DaemonSetSpec"), _openapi_validate) + _openapi_field_updatestrategy = haskey(_openapi_object, "updateStrategy") ? _decode(Union{Absent,IoK8sApiAppsV1DaemonSetUpdateStrategy,Nothing}, _openapi_object["updateStrategy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("minReadySeconds","revisionHistoryLimit","selector","template","updateStrategy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSetSpec(; minreadyseconds = _openapi_field_minreadyseconds, revisionhistorylimit = _openapi_field_revisionhistorylimit, selector = _openapi_field_selector, template = _openapi_field_template, updatestrategy = _openapi_field_updatestrategy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSetSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.minreadyseconds isa Absent || (_openapi_output["minReadySeconds"] = _encode(_openapi_value.minreadyseconds)) + _openapi_value.revisionhistorylimit isa Absent || (_openapi_output["revisionHistoryLimit"] = _encode(_openapi_value.revisionhistorylimit)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + _openapi_value.updatestrategy isa Absent || (_openapi_output["updateStrategy"] = _encode(_openapi_value.updatestrategy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetSpec"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSetSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSetSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.minreadyseconds isa Absent || push!(_openapi_output, "minReadySeconds" => _openapi_value.minreadyseconds) + _openapi_value.revisionhistorylimit isa Absent || push!(_openapi_output, "revisionHistoryLimit" => _openapi_value.revisionhistorylimit) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + _openapi_value.updatestrategy isa Absent || push!(_openapi_output, "updateStrategy" => _openapi_value.updatestrategy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSetCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSetCondition}, value) = _decode(IoK8sApiAppsV1DaemonSetCondition, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSetCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSetCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSetCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiAppsV1DaemonSetCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAppsV1DaemonSetCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSetCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSetCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetCondition"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSetCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSetCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSetStatus + collisioncount::Union{Absent,Int32,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1DaemonSetCondition}}} = ABSENT + currentnumberscheduled::Int32 + desirednumberscheduled::Int32 + numberavailable::Union{Absent,Int32,Nothing} = ABSENT + numbermisscheduled::Int32 + numberready::Int32 + numberunavailable::Union{Absent,Int32,Nothing} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + updatednumberscheduled::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSetStatus}, value) = _decode(IoK8sApiAppsV1DaemonSetStatus, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSetStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSetStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSetStatus") + _openapi_field_collisioncount = haskey(_openapi_object, "collisionCount") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["collisionCount"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1DaemonSetCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currentnumberscheduled = _decode(Int32, _required(_openapi_object, "currentNumberScheduled", "IoK8sApiAppsV1DaemonSetStatus"), _openapi_validate) + _openapi_field_desirednumberscheduled = _decode(Int32, _required(_openapi_object, "desiredNumberScheduled", "IoK8sApiAppsV1DaemonSetStatus"), _openapi_validate) + _openapi_field_numberavailable = haskey(_openapi_object, "numberAvailable") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["numberAvailable"], _openapi_validate) : ABSENT + _openapi_field_numbermisscheduled = _decode(Int32, _required(_openapi_object, "numberMisscheduled", "IoK8sApiAppsV1DaemonSetStatus"), _openapi_validate) + _openapi_field_numberready = _decode(Int32, _required(_openapi_object, "numberReady", "IoK8sApiAppsV1DaemonSetStatus"), _openapi_validate) + _openapi_field_numberunavailable = haskey(_openapi_object, "numberUnavailable") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["numberUnavailable"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_updatednumberscheduled = haskey(_openapi_object, "updatedNumberScheduled") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["updatedNumberScheduled"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("collisionCount","conditions","currentNumberScheduled","desiredNumberScheduled","numberAvailable","numberMisscheduled","numberReady","numberUnavailable","observedGeneration","updatedNumberScheduled") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSetStatus(; collisioncount = _openapi_field_collisioncount, conditions = _openapi_field_conditions, currentnumberscheduled = _openapi_field_currentnumberscheduled, desirednumberscheduled = _openapi_field_desirednumberscheduled, numberavailable = _openapi_field_numberavailable, numbermisscheduled = _openapi_field_numbermisscheduled, numberready = _openapi_field_numberready, numberunavailable = _openapi_field_numberunavailable, observedgeneration = _openapi_field_observedgeneration, updatednumberscheduled = _openapi_field_updatednumberscheduled, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSetStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.collisioncount isa Absent || (_openapi_output["collisionCount"] = _encode(_openapi_value.collisioncount)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currentnumberscheduled isa Absent || (_openapi_output["currentNumberScheduled"] = _encode(_openapi_value.currentnumberscheduled)) + _openapi_value.desirednumberscheduled isa Absent || (_openapi_output["desiredNumberScheduled"] = _encode(_openapi_value.desirednumberscheduled)) + _openapi_value.numberavailable isa Absent || (_openapi_output["numberAvailable"] = _encode(_openapi_value.numberavailable)) + _openapi_value.numbermisscheduled isa Absent || (_openapi_output["numberMisscheduled"] = _encode(_openapi_value.numbermisscheduled)) + _openapi_value.numberready isa Absent || (_openapi_output["numberReady"] = _encode(_openapi_value.numberready)) + _openapi_value.numberunavailable isa Absent || (_openapi_output["numberUnavailable"] = _encode(_openapi_value.numberunavailable)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.updatednumberscheduled isa Absent || (_openapi_output["updatedNumberScheduled"] = _encode(_openapi_value.updatednumberscheduled)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetStatus"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSetStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSetStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.collisioncount isa Absent || push!(_openapi_output, "collisionCount" => _openapi_value.collisioncount) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currentnumberscheduled isa Absent || push!(_openapi_output, "currentNumberScheduled" => _openapi_value.currentnumberscheduled) + _openapi_value.desirednumberscheduled isa Absent || push!(_openapi_output, "desiredNumberScheduled" => _openapi_value.desirednumberscheduled) + _openapi_value.numberavailable isa Absent || push!(_openapi_output, "numberAvailable" => _openapi_value.numberavailable) + _openapi_value.numbermisscheduled isa Absent || push!(_openapi_output, "numberMisscheduled" => _openapi_value.numbermisscheduled) + _openapi_value.numberready isa Absent || push!(_openapi_output, "numberReady" => _openapi_value.numberready) + _openapi_value.numberunavailable isa Absent || push!(_openapi_output, "numberUnavailable" => _openapi_value.numberunavailable) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.updatednumberscheduled isa Absent || push!(_openapi_output, "updatedNumberScheduled" => _openapi_value.updatednumberscheduled) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSet + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAppsV1DaemonSetSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAppsV1DaemonSetStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSet}, value) = _decode(IoK8sApiAppsV1DaemonSet, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSet}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSet"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSet"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSet") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAppsV1DaemonSetSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAppsV1DaemonSetStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSet(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSet) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSet"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSet"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSet) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DaemonSetList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAppsV1DaemonSet}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DaemonSetList}, value) = _decode(IoK8sApiAppsV1DaemonSetList, value, true) +function _decode(::Type{IoK8sApiAppsV1DaemonSetList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetList"), _openapi_raw, "decoding IoK8sApiAppsV1DaemonSetList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DaemonSetList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAppsV1DaemonSet}}, _required(_openapi_object, "items", "IoK8sApiAppsV1DaemonSetList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DaemonSetList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DaemonSetList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DaemonSetList"), _openapi_output, "encoding IoK8sApiAppsV1DaemonSetList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DaemonSetList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1RollingUpdateDeployment + maxsurge::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + maxunavailable::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1RollingUpdateDeployment}, value) = _decode(IoK8sApiAppsV1RollingUpdateDeployment, value, true) +function _decode(::Type{IoK8sApiAppsV1RollingUpdateDeployment}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment"), _openapi_raw, "decoding IoK8sApiAppsV1RollingUpdateDeployment"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1RollingUpdateDeployment") + _openapi_field_maxsurge = haskey(_openapi_object, "maxSurge") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxSurge"], _openapi_validate) : ABSENT + _openapi_field_maxunavailable = haskey(_openapi_object, "maxUnavailable") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxUnavailable"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("maxSurge","maxUnavailable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1RollingUpdateDeployment(; maxsurge = _openapi_field_maxsurge, maxunavailable = _openapi_field_maxunavailable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1RollingUpdateDeployment) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.maxsurge isa Absent || (_openapi_output["maxSurge"] = _encode(_openapi_value.maxsurge)) + _openapi_value.maxunavailable isa Absent || (_openapi_output["maxUnavailable"] = _encode(_openapi_value.maxunavailable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateDeployment"), _openapi_output, "encoding IoK8sApiAppsV1RollingUpdateDeployment"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1RollingUpdateDeployment) + _openapi_output = Pair{String,Any}[] + _openapi_value.maxsurge isa Absent || push!(_openapi_output, "maxSurge" => _openapi_value.maxsurge) + _openapi_value.maxunavailable isa Absent || push!(_openapi_output, "maxUnavailable" => _openapi_value.maxunavailable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DeploymentStrategy + rollingupdate::Union{Absent,IoK8sApiAppsV1RollingUpdateDeployment,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DeploymentStrategy}, value) = _decode(IoK8sApiAppsV1DeploymentStrategy, value, true) +function _decode(::Type{IoK8sApiAppsV1DeploymentStrategy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy"), _openapi_raw, "decoding IoK8sApiAppsV1DeploymentStrategy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DeploymentStrategy") + _openapi_field_rollingupdate = haskey(_openapi_object, "rollingUpdate") ? _decode(Union{Absent,IoK8sApiAppsV1RollingUpdateDeployment,Nothing}, _openapi_object["rollingUpdate"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("rollingUpdate","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DeploymentStrategy(; rollingupdate = _openapi_field_rollingupdate, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DeploymentStrategy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.rollingupdate isa Absent || (_openapi_output["rollingUpdate"] = _encode(_openapi_value.rollingupdate)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStrategy"), _openapi_output, "encoding IoK8sApiAppsV1DeploymentStrategy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DeploymentStrategy) + _openapi_output = Pair{String,Any}[] + _openapi_value.rollingupdate isa Absent || push!(_openapi_output, "rollingUpdate" => _openapi_value.rollingupdate) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DeploymentSpec + minreadyseconds::Union{Absent,Int32,Nothing} = ABSENT + paused::Union{Absent,Bool,Nothing} = ABSENT + progressdeadlineseconds::Union{Absent,Int32,Nothing} = ABSENT + replicas::Union{Absent,Int32,Nothing} = ABSENT + revisionhistorylimit::Union{Absent,Int32,Nothing} = ABSENT + selector::IoK8sApimachineryPkgApisMetaV1LabelSelector + strategy::Union{Absent,IoK8sApiAppsV1DeploymentStrategy,Nothing} = ABSENT + template::IoK8sApiCoreV1PodTemplateSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DeploymentSpec}, value) = _decode(IoK8sApiAppsV1DeploymentSpec, value, true) +function _decode(::Type{IoK8sApiAppsV1DeploymentSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentSpec"), _openapi_raw, "decoding IoK8sApiAppsV1DeploymentSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DeploymentSpec") + _openapi_field_minreadyseconds = haskey(_openapi_object, "minReadySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReadySeconds"], _openapi_validate) : ABSENT + _openapi_field_paused = haskey(_openapi_object, "paused") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["paused"], _openapi_validate) : ABSENT + _openapi_field_progressdeadlineseconds = haskey(_openapi_object, "progressDeadlineSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["progressDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_field_revisionhistorylimit = haskey(_openapi_object, "revisionHistoryLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["revisionHistoryLimit"], _openapi_validate) : ABSENT + _openapi_field_selector = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, _required(_openapi_object, "selector", "IoK8sApiAppsV1DeploymentSpec"), _openapi_validate) + _openapi_field_strategy = haskey(_openapi_object, "strategy") ? _decode(Union{Absent,IoK8sApiAppsV1DeploymentStrategy,Nothing}, _openapi_object["strategy"], _openapi_validate) : ABSENT + _openapi_field_template = _decode(IoK8sApiCoreV1PodTemplateSpec, _required(_openapi_object, "template", "IoK8sApiAppsV1DeploymentSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("minReadySeconds","paused","progressDeadlineSeconds","replicas","revisionHistoryLimit","selector","strategy","template") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DeploymentSpec(; minreadyseconds = _openapi_field_minreadyseconds, paused = _openapi_field_paused, progressdeadlineseconds = _openapi_field_progressdeadlineseconds, replicas = _openapi_field_replicas, revisionhistorylimit = _openapi_field_revisionhistorylimit, selector = _openapi_field_selector, strategy = _openapi_field_strategy, template = _openapi_field_template, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DeploymentSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.minreadyseconds isa Absent || (_openapi_output["minReadySeconds"] = _encode(_openapi_value.minreadyseconds)) + _openapi_value.paused isa Absent || (_openapi_output["paused"] = _encode(_openapi_value.paused)) + _openapi_value.progressdeadlineseconds isa Absent || (_openapi_output["progressDeadlineSeconds"] = _encode(_openapi_value.progressdeadlineseconds)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.revisionhistorylimit isa Absent || (_openapi_output["revisionHistoryLimit"] = _encode(_openapi_value.revisionhistorylimit)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.strategy isa Absent || (_openapi_output["strategy"] = _encode(_openapi_value.strategy)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentSpec"), _openapi_output, "encoding IoK8sApiAppsV1DeploymentSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DeploymentSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.minreadyseconds isa Absent || push!(_openapi_output, "minReadySeconds" => _openapi_value.minreadyseconds) + _openapi_value.paused isa Absent || push!(_openapi_output, "paused" => _openapi_value.paused) + _openapi_value.progressdeadlineseconds isa Absent || push!(_openapi_output, "progressDeadlineSeconds" => _openapi_value.progressdeadlineseconds) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.revisionhistorylimit isa Absent || push!(_openapi_output, "revisionHistoryLimit" => _openapi_value.revisionhistorylimit) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.strategy isa Absent || push!(_openapi_output, "strategy" => _openapi_value.strategy) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DeploymentCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lastupdatetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DeploymentCondition}, value) = _decode(IoK8sApiAppsV1DeploymentCondition, value, true) +function _decode(::Type{IoK8sApiAppsV1DeploymentCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentCondition"), _openapi_raw, "decoding IoK8sApiAppsV1DeploymentCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DeploymentCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_lastupdatetime = haskey(_openapi_object, "lastUpdateTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastUpdateTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiAppsV1DeploymentCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAppsV1DeploymentCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","lastUpdateTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DeploymentCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, lastupdatetime = _openapi_field_lastupdatetime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DeploymentCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.lastupdatetime isa Absent || (_openapi_output["lastUpdateTime"] = _encode(_openapi_value.lastupdatetime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentCondition"), _openapi_output, "encoding IoK8sApiAppsV1DeploymentCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DeploymentCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.lastupdatetime isa Absent || push!(_openapi_output, "lastUpdateTime" => _openapi_value.lastupdatetime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DeploymentStatus + availablereplicas::Union{Absent,Int32,Nothing} = ABSENT + collisioncount::Union{Absent,Int32,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1DeploymentCondition}}} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + readyreplicas::Union{Absent,Int32,Nothing} = ABSENT + replicas::Union{Absent,Int32,Nothing} = ABSENT + terminatingreplicas::Union{Absent,Int32,Nothing} = ABSENT + unavailablereplicas::Union{Absent,Int32,Nothing} = ABSENT + updatedreplicas::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DeploymentStatus}, value) = _decode(IoK8sApiAppsV1DeploymentStatus, value, true) +function _decode(::Type{IoK8sApiAppsV1DeploymentStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStatus"), _openapi_raw, "decoding IoK8sApiAppsV1DeploymentStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DeploymentStatus") + _openapi_field_availablereplicas = haskey(_openapi_object, "availableReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["availableReplicas"], _openapi_validate) : ABSENT + _openapi_field_collisioncount = haskey(_openapi_object, "collisionCount") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["collisionCount"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1DeploymentCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_readyreplicas = haskey(_openapi_object, "readyReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["readyReplicas"], _openapi_validate) : ABSENT + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_field_terminatingreplicas = haskey(_openapi_object, "terminatingReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["terminatingReplicas"], _openapi_validate) : ABSENT + _openapi_field_unavailablereplicas = haskey(_openapi_object, "unavailableReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["unavailableReplicas"], _openapi_validate) : ABSENT + _openapi_field_updatedreplicas = haskey(_openapi_object, "updatedReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["updatedReplicas"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("availableReplicas","collisionCount","conditions","observedGeneration","readyReplicas","replicas","terminatingReplicas","unavailableReplicas","updatedReplicas") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DeploymentStatus(; availablereplicas = _openapi_field_availablereplicas, collisioncount = _openapi_field_collisioncount, conditions = _openapi_field_conditions, observedgeneration = _openapi_field_observedgeneration, readyreplicas = _openapi_field_readyreplicas, replicas = _openapi_field_replicas, terminatingreplicas = _openapi_field_terminatingreplicas, unavailablereplicas = _openapi_field_unavailablereplicas, updatedreplicas = _openapi_field_updatedreplicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DeploymentStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.availablereplicas isa Absent || (_openapi_output["availableReplicas"] = _encode(_openapi_value.availablereplicas)) + _openapi_value.collisioncount isa Absent || (_openapi_output["collisionCount"] = _encode(_openapi_value.collisioncount)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.readyreplicas isa Absent || (_openapi_output["readyReplicas"] = _encode(_openapi_value.readyreplicas)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.terminatingreplicas isa Absent || (_openapi_output["terminatingReplicas"] = _encode(_openapi_value.terminatingreplicas)) + _openapi_value.unavailablereplicas isa Absent || (_openapi_output["unavailableReplicas"] = _encode(_openapi_value.unavailablereplicas)) + _openapi_value.updatedreplicas isa Absent || (_openapi_output["updatedReplicas"] = _encode(_openapi_value.updatedreplicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentStatus"), _openapi_output, "encoding IoK8sApiAppsV1DeploymentStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DeploymentStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.availablereplicas isa Absent || push!(_openapi_output, "availableReplicas" => _openapi_value.availablereplicas) + _openapi_value.collisioncount isa Absent || push!(_openapi_output, "collisionCount" => _openapi_value.collisioncount) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.readyreplicas isa Absent || push!(_openapi_output, "readyReplicas" => _openapi_value.readyreplicas) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.terminatingreplicas isa Absent || push!(_openapi_output, "terminatingReplicas" => _openapi_value.terminatingreplicas) + _openapi_value.unavailablereplicas isa Absent || push!(_openapi_output, "unavailableReplicas" => _openapi_value.unavailablereplicas) + _openapi_value.updatedreplicas isa Absent || push!(_openapi_output, "updatedReplicas" => _openapi_value.updatedreplicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1Deployment + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAppsV1DeploymentSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAppsV1DeploymentStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1Deployment}, value) = _decode(IoK8sApiAppsV1Deployment, value, true) +function _decode(::Type{IoK8sApiAppsV1Deployment}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.Deployment"), _openapi_raw, "decoding IoK8sApiAppsV1Deployment"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1Deployment") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAppsV1DeploymentSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAppsV1DeploymentStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1Deployment(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1Deployment) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.Deployment"), _openapi_output, "encoding IoK8sApiAppsV1Deployment"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1Deployment) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1DeploymentList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAppsV1Deployment}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1DeploymentList}, value) = _decode(IoK8sApiAppsV1DeploymentList, value, true) +function _decode(::Type{IoK8sApiAppsV1DeploymentList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentList"), _openapi_raw, "decoding IoK8sApiAppsV1DeploymentList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1DeploymentList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAppsV1Deployment}}, _required(_openapi_object, "items", "IoK8sApiAppsV1DeploymentList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1DeploymentList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1DeploymentList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.DeploymentList"), _openapi_output, "encoding IoK8sApiAppsV1DeploymentList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1DeploymentList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ReplicaSetSpec + minreadyseconds::Union{Absent,Int32,Nothing} = ABSENT + replicas::Union{Absent,Int32,Nothing} = ABSENT + selector::IoK8sApimachineryPkgApisMetaV1LabelSelector + template::Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ReplicaSetSpec}, value) = _decode(IoK8sApiAppsV1ReplicaSetSpec, value, true) +function _decode(::Type{IoK8sApiAppsV1ReplicaSetSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec"), _openapi_raw, "decoding IoK8sApiAppsV1ReplicaSetSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ReplicaSetSpec") + _openapi_field_minreadyseconds = haskey(_openapi_object, "minReadySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReadySeconds"], _openapi_validate) : ABSENT + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_field_selector = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, _required(_openapi_object, "selector", "IoK8sApiAppsV1ReplicaSetSpec"), _openapi_validate) + _openapi_field_template = haskey(_openapi_object, "template") ? _decode(Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing}, _openapi_object["template"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("minReadySeconds","replicas","selector","template") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ReplicaSetSpec(; minreadyseconds = _openapi_field_minreadyseconds, replicas = _openapi_field_replicas, selector = _openapi_field_selector, template = _openapi_field_template, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ReplicaSetSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.minreadyseconds isa Absent || (_openapi_output["minReadySeconds"] = _encode(_openapi_value.minreadyseconds)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetSpec"), _openapi_output, "encoding IoK8sApiAppsV1ReplicaSetSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ReplicaSetSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.minreadyseconds isa Absent || push!(_openapi_output, "minReadySeconds" => _openapi_value.minreadyseconds) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ReplicaSetCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ReplicaSetCondition}, value) = _decode(IoK8sApiAppsV1ReplicaSetCondition, value, true) +function _decode(::Type{IoK8sApiAppsV1ReplicaSetCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition"), _openapi_raw, "decoding IoK8sApiAppsV1ReplicaSetCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ReplicaSetCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiAppsV1ReplicaSetCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAppsV1ReplicaSetCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ReplicaSetCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ReplicaSetCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetCondition"), _openapi_output, "encoding IoK8sApiAppsV1ReplicaSetCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ReplicaSetCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ReplicaSetStatus + availablereplicas::Union{Absent,Int32,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1ReplicaSetCondition}}} = ABSENT + fullylabeledreplicas::Union{Absent,Int32,Nothing} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + readyreplicas::Union{Absent,Int32,Nothing} = ABSENT + replicas::Int32 + terminatingreplicas::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ReplicaSetStatus}, value) = _decode(IoK8sApiAppsV1ReplicaSetStatus, value, true) +function _decode(::Type{IoK8sApiAppsV1ReplicaSetStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus"), _openapi_raw, "decoding IoK8sApiAppsV1ReplicaSetStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ReplicaSetStatus") + _openapi_field_availablereplicas = haskey(_openapi_object, "availableReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["availableReplicas"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1ReplicaSetCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_fullylabeledreplicas = haskey(_openapi_object, "fullyLabeledReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["fullyLabeledReplicas"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_readyreplicas = haskey(_openapi_object, "readyReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["readyReplicas"], _openapi_validate) : ABSENT + _openapi_field_replicas = _decode(Int32, _required(_openapi_object, "replicas", "IoK8sApiAppsV1ReplicaSetStatus"), _openapi_validate) + _openapi_field_terminatingreplicas = haskey(_openapi_object, "terminatingReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["terminatingReplicas"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("availableReplicas","conditions","fullyLabeledReplicas","observedGeneration","readyReplicas","replicas","terminatingReplicas") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ReplicaSetStatus(; availablereplicas = _openapi_field_availablereplicas, conditions = _openapi_field_conditions, fullylabeledreplicas = _openapi_field_fullylabeledreplicas, observedgeneration = _openapi_field_observedgeneration, readyreplicas = _openapi_field_readyreplicas, replicas = _openapi_field_replicas, terminatingreplicas = _openapi_field_terminatingreplicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ReplicaSetStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.availablereplicas isa Absent || (_openapi_output["availableReplicas"] = _encode(_openapi_value.availablereplicas)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.fullylabeledreplicas isa Absent || (_openapi_output["fullyLabeledReplicas"] = _encode(_openapi_value.fullylabeledreplicas)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.readyreplicas isa Absent || (_openapi_output["readyReplicas"] = _encode(_openapi_value.readyreplicas)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.terminatingreplicas isa Absent || (_openapi_output["terminatingReplicas"] = _encode(_openapi_value.terminatingreplicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetStatus"), _openapi_output, "encoding IoK8sApiAppsV1ReplicaSetStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ReplicaSetStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.availablereplicas isa Absent || push!(_openapi_output, "availableReplicas" => _openapi_value.availablereplicas) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.fullylabeledreplicas isa Absent || push!(_openapi_output, "fullyLabeledReplicas" => _openapi_value.fullylabeledreplicas) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.readyreplicas isa Absent || push!(_openapi_output, "readyReplicas" => _openapi_value.readyreplicas) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.terminatingreplicas isa Absent || push!(_openapi_output, "terminatingReplicas" => _openapi_value.terminatingreplicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ReplicaSet + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAppsV1ReplicaSetSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAppsV1ReplicaSetStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ReplicaSet}, value) = _decode(IoK8sApiAppsV1ReplicaSet, value, true) +function _decode(::Type{IoK8sApiAppsV1ReplicaSet}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSet"), _openapi_raw, "decoding IoK8sApiAppsV1ReplicaSet"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ReplicaSet") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAppsV1ReplicaSetSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAppsV1ReplicaSetStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ReplicaSet(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ReplicaSet) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSet"), _openapi_output, "encoding IoK8sApiAppsV1ReplicaSet"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ReplicaSet) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1ReplicaSetList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAppsV1ReplicaSet}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1ReplicaSetList}, value) = _decode(IoK8sApiAppsV1ReplicaSetList, value, true) +function _decode(::Type{IoK8sApiAppsV1ReplicaSetList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetList"), _openapi_raw, "decoding IoK8sApiAppsV1ReplicaSetList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1ReplicaSetList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAppsV1ReplicaSet}}, _required(_openapi_object, "items", "IoK8sApiAppsV1ReplicaSetList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1ReplicaSetList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1ReplicaSetList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.ReplicaSetList"), _openapi_output, "encoding IoK8sApiAppsV1ReplicaSetList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1ReplicaSetList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1RollingUpdateStatefulSetStrategy + maxunavailable::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1RollingUpdateStatefulSetStrategy}, value) = _decode(IoK8sApiAppsV1RollingUpdateStatefulSetStrategy, value, true) +function _decode(::Type{IoK8sApiAppsV1RollingUpdateStatefulSetStrategy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy"), _openapi_raw, "decoding IoK8sApiAppsV1RollingUpdateStatefulSetStrategy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1RollingUpdateStatefulSetStrategy") + _openapi_field_maxunavailable = haskey(_openapi_object, "maxUnavailable") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxUnavailable"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("maxUnavailable","partition") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1RollingUpdateStatefulSetStrategy(; maxunavailable = _openapi_field_maxunavailable, partition = _openapi_field_partition, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1RollingUpdateStatefulSetStrategy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.maxunavailable isa Absent || (_openapi_output["maxUnavailable"] = _encode(_openapi_value.maxunavailable)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy"), _openapi_output, "encoding IoK8sApiAppsV1RollingUpdateStatefulSetStrategy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1RollingUpdateStatefulSetStrategy) + _openapi_output = Pair{String,Any}[] + _openapi_value.maxunavailable isa Absent || push!(_openapi_output, "maxUnavailable" => _openapi_value.maxunavailable) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetOrdinals + start::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetOrdinals}, value) = _decode(IoK8sApiAppsV1StatefulSetOrdinals, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetOrdinals}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetOrdinals"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetOrdinals") + _openapi_field_start = haskey(_openapi_object, "start") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["start"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("start",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetOrdinals(; start = _openapi_field_start, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetOrdinals) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.start isa Absent || (_openapi_output["start"] = _encode(_openapi_value.start)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetOrdinals"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetOrdinals"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetOrdinals) + _openapi_output = Pair{String,Any}[] + _openapi_value.start isa Absent || push!(_openapi_output, "start" => _openapi_value.start) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy + whendeleted::Union{Absent,Nothing,String} = ABSENT + whenscaled::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy}, value) = _decode(IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy") + _openapi_field_whendeleted = haskey(_openapi_object, "whenDeleted") ? _decode(Union{Absent,Nothing,String}, _openapi_object["whenDeleted"], _openapi_validate) : ABSENT + _openapi_field_whenscaled = haskey(_openapi_object, "whenScaled") ? _decode(Union{Absent,Nothing,String}, _openapi_object["whenScaled"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("whenDeleted","whenScaled") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy(; whendeleted = _openapi_field_whendeleted, whenscaled = _openapi_field_whenscaled, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.whendeleted isa Absent || (_openapi_output["whenDeleted"] = _encode(_openapi_value.whendeleted)) + _openapi_value.whenscaled isa Absent || (_openapi_output["whenScaled"] = _encode(_openapi_value.whenscaled)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.whendeleted isa Absent || push!(_openapi_output, "whenDeleted" => _openapi_value.whendeleted) + _openapi_value.whenscaled isa Absent || push!(_openapi_output, "whenScaled" => _openapi_value.whenscaled) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetUpdateStrategy + rollingupdate::Union{Absent,IoK8sApiAppsV1RollingUpdateStatefulSetStrategy,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetUpdateStrategy}, value) = _decode(IoK8sApiAppsV1StatefulSetUpdateStrategy, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetUpdateStrategy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetUpdateStrategy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetUpdateStrategy") + _openapi_field_rollingupdate = haskey(_openapi_object, "rollingUpdate") ? _decode(Union{Absent,IoK8sApiAppsV1RollingUpdateStatefulSetStrategy,Nothing}, _openapi_object["rollingUpdate"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("rollingUpdate","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetUpdateStrategy(; rollingupdate = _openapi_field_rollingupdate, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetUpdateStrategy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.rollingupdate isa Absent || (_openapi_output["rollingUpdate"] = _encode(_openapi_value.rollingupdate)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetUpdateStrategy"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetUpdateStrategy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetUpdateStrategy) + _openapi_output = Pair{String,Any}[] + _openapi_value.rollingupdate isa Absent || push!(_openapi_output, "rollingUpdate" => _openapi_value.rollingupdate) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResourceStatuses"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResourceStatuses"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResources"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResources"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/capacity"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/capacity"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimCondition + lastprobetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimCondition}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimCondition") + _openapi_field_lastprobetime = haskey(_openapi_object, "lastProbeTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastProbeTime"], _openapi_validate) : ABSENT + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1PersistentVolumeClaimCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1PersistentVolumeClaimCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastProbeTime","lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimCondition(; lastprobetime = _openapi_field_lastprobetime, lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastprobetime isa Absent || (_openapi_output["lastProbeTime"] = _encode(_openapi_value.lastprobetime)) + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastprobetime isa Absent || push!(_openapi_output, "lastProbeTime" => _openapi_value.lastprobetime) + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ModifyVolumeStatus + status::String + targetvolumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ModifyVolumeStatus}, value) = _decode(IoK8sApiCoreV1ModifyVolumeStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ModifyVolumeStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ModifyVolumeStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ModifyVolumeStatus") + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1ModifyVolumeStatus"), _openapi_validate) + _openapi_field_targetvolumeattributesclassname = haskey(_openapi_object, "targetVolumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["targetVolumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("status","targetVolumeAttributesClassName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ModifyVolumeStatus(; status = _openapi_field_status, targetvolumeattributesclassname = _openapi_field_targetvolumeattributesclassname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ModifyVolumeStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.targetvolumeattributesclassname isa Absent || (_openapi_output["targetVolumeAttributesClassName"] = _encode(_openapi_value.targetvolumeattributesclassname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus"), _openapi_output, "encoding IoK8sApiCoreV1ModifyVolumeStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ModifyVolumeStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.targetvolumeattributesclassname isa Absent || push!(_openapi_output, "targetVolumeAttributesClassName" => _openapi_value.targetvolumeattributesclassname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatus + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + allocatedresourcestatuses::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses,Nothing} = ABSENT + allocatedresources::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources,Nothing} = ABSENT + capacity::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition}}} = ABSENT + currentvolumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + modifyvolumestatus::Union{Absent,IoK8sApiCoreV1ModifyVolumeStatus,Nothing} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatus}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatus") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_allocatedresourcestatuses = haskey(_openapi_object, "allocatedResourceStatuses") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses,Nothing}, _openapi_object["allocatedResourceStatuses"], _openapi_validate) : ABSENT + _openapi_field_allocatedresources = haskey(_openapi_object, "allocatedResources") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources,Nothing}, _openapi_object["allocatedResources"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currentvolumeattributesclassname = haskey(_openapi_object, "currentVolumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["currentVolumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_modifyvolumestatus = haskey(_openapi_object, "modifyVolumeStatus") ? _decode(Union{Absent,IoK8sApiCoreV1ModifyVolumeStatus,Nothing}, _openapi_object["modifyVolumeStatus"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","allocatedResourceStatuses","allocatedResources","capacity","conditions","currentVolumeAttributesClassName","modifyVolumeStatus","phase") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatus(; accessmodes = _openapi_field_accessmodes, allocatedresourcestatuses = _openapi_field_allocatedresourcestatuses, allocatedresources = _openapi_field_allocatedresources, capacity = _openapi_field_capacity, conditions = _openapi_field_conditions, currentvolumeattributesclassname = _openapi_field_currentvolumeattributesclassname, modifyvolumestatus = _openapi_field_modifyvolumestatus, phase = _openapi_field_phase, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.allocatedresourcestatuses isa Absent || (_openapi_output["allocatedResourceStatuses"] = _encode(_openapi_value.allocatedresourcestatuses)) + _openapi_value.allocatedresources isa Absent || (_openapi_output["allocatedResources"] = _encode(_openapi_value.allocatedresources)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currentvolumeattributesclassname isa Absent || (_openapi_output["currentVolumeAttributesClassName"] = _encode(_openapi_value.currentvolumeattributesclassname)) + _openapi_value.modifyvolumestatus isa Absent || (_openapi_output["modifyVolumeStatus"] = _encode(_openapi_value.modifyvolumestatus)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.allocatedresourcestatuses isa Absent || push!(_openapi_output, "allocatedResourceStatuses" => _openapi_value.allocatedresourcestatuses) + _openapi_value.allocatedresources isa Absent || push!(_openapi_output, "allocatedResources" => _openapi_value.allocatedresources) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currentvolumeattributesclassname isa Absent || push!(_openapi_output, "currentVolumeAttributesClassName" => _openapi_value.currentvolumeattributesclassname) + _openapi_value.modifyvolumestatus isa Absent || push!(_openapi_output, "modifyVolumeStatus" => _openapi_value.modifyvolumestatus) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaim + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaim}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaim") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaim(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetSpec + minreadyseconds::Union{Absent,Int32,Nothing} = ABSENT + ordinals::Union{Absent,IoK8sApiAppsV1StatefulSetOrdinals,Nothing} = ABSENT + persistentvolumeclaimretentionpolicy::Union{Absent,IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy,Nothing} = ABSENT + podmanagementpolicy::Union{Absent,Nothing,String} = ABSENT + replicas::Union{Absent,Int32,Nothing} = ABSENT + revisionhistorylimit::Union{Absent,Int32,Nothing} = ABSENT + selector::IoK8sApimachineryPkgApisMetaV1LabelSelector + servicename::Union{Absent,Nothing,String} = ABSENT + template::IoK8sApiCoreV1PodTemplateSpec + updatestrategy::Union{Absent,IoK8sApiAppsV1StatefulSetUpdateStrategy,Nothing} = ABSENT + volumeclaimtemplates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaim}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetSpec}, value) = _decode(IoK8sApiAppsV1StatefulSetSpec, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetSpec") + _openapi_field_minreadyseconds = haskey(_openapi_object, "minReadySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReadySeconds"], _openapi_validate) : ABSENT + _openapi_field_ordinals = haskey(_openapi_object, "ordinals") ? _decode(Union{Absent,IoK8sApiAppsV1StatefulSetOrdinals,Nothing}, _openapi_object["ordinals"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumeclaimretentionpolicy = haskey(_openapi_object, "persistentVolumeClaimRetentionPolicy") ? _decode(Union{Absent,IoK8sApiAppsV1StatefulSetPersistentVolumeClaimRetentionPolicy,Nothing}, _openapi_object["persistentVolumeClaimRetentionPolicy"], _openapi_validate) : ABSENT + _openapi_field_podmanagementpolicy = haskey(_openapi_object, "podManagementPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podManagementPolicy"], _openapi_validate) : ABSENT + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_field_revisionhistorylimit = haskey(_openapi_object, "revisionHistoryLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["revisionHistoryLimit"], _openapi_validate) : ABSENT + _openapi_field_selector = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, _required(_openapi_object, "selector", "IoK8sApiAppsV1StatefulSetSpec"), _openapi_validate) + _openapi_field_servicename = haskey(_openapi_object, "serviceName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceName"], _openapi_validate) : ABSENT + _openapi_field_template = _decode(IoK8sApiCoreV1PodTemplateSpec, _required(_openapi_object, "template", "IoK8sApiAppsV1StatefulSetSpec"), _openapi_validate) + _openapi_field_updatestrategy = haskey(_openapi_object, "updateStrategy") ? _decode(Union{Absent,IoK8sApiAppsV1StatefulSetUpdateStrategy,Nothing}, _openapi_object["updateStrategy"], _openapi_validate) : ABSENT + _openapi_field_volumeclaimtemplates = haskey(_openapi_object, "volumeClaimTemplates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaim}}}, _openapi_object["volumeClaimTemplates"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("minReadySeconds","ordinals","persistentVolumeClaimRetentionPolicy","podManagementPolicy","replicas","revisionHistoryLimit","selector","serviceName","template","updateStrategy","volumeClaimTemplates") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetSpec(; minreadyseconds = _openapi_field_minreadyseconds, ordinals = _openapi_field_ordinals, persistentvolumeclaimretentionpolicy = _openapi_field_persistentvolumeclaimretentionpolicy, podmanagementpolicy = _openapi_field_podmanagementpolicy, replicas = _openapi_field_replicas, revisionhistorylimit = _openapi_field_revisionhistorylimit, selector = _openapi_field_selector, servicename = _openapi_field_servicename, template = _openapi_field_template, updatestrategy = _openapi_field_updatestrategy, volumeclaimtemplates = _openapi_field_volumeclaimtemplates, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.minreadyseconds isa Absent || (_openapi_output["minReadySeconds"] = _encode(_openapi_value.minreadyseconds)) + _openapi_value.ordinals isa Absent || (_openapi_output["ordinals"] = _encode(_openapi_value.ordinals)) + _openapi_value.persistentvolumeclaimretentionpolicy isa Absent || (_openapi_output["persistentVolumeClaimRetentionPolicy"] = _encode(_openapi_value.persistentvolumeclaimretentionpolicy)) + _openapi_value.podmanagementpolicy isa Absent || (_openapi_output["podManagementPolicy"] = _encode(_openapi_value.podmanagementpolicy)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.revisionhistorylimit isa Absent || (_openapi_output["revisionHistoryLimit"] = _encode(_openapi_value.revisionhistorylimit)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.servicename isa Absent || (_openapi_output["serviceName"] = _encode(_openapi_value.servicename)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + _openapi_value.updatestrategy isa Absent || (_openapi_output["updateStrategy"] = _encode(_openapi_value.updatestrategy)) + _openapi_value.volumeclaimtemplates isa Absent || (_openapi_output["volumeClaimTemplates"] = _encode(_openapi_value.volumeclaimtemplates)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetSpec"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.minreadyseconds isa Absent || push!(_openapi_output, "minReadySeconds" => _openapi_value.minreadyseconds) + _openapi_value.ordinals isa Absent || push!(_openapi_output, "ordinals" => _openapi_value.ordinals) + _openapi_value.persistentvolumeclaimretentionpolicy isa Absent || push!(_openapi_output, "persistentVolumeClaimRetentionPolicy" => _openapi_value.persistentvolumeclaimretentionpolicy) + _openapi_value.podmanagementpolicy isa Absent || push!(_openapi_output, "podManagementPolicy" => _openapi_value.podmanagementpolicy) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.revisionhistorylimit isa Absent || push!(_openapi_output, "revisionHistoryLimit" => _openapi_value.revisionhistorylimit) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.servicename isa Absent || push!(_openapi_output, "serviceName" => _openapi_value.servicename) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + _openapi_value.updatestrategy isa Absent || push!(_openapi_output, "updateStrategy" => _openapi_value.updatestrategy) + _openapi_value.volumeclaimtemplates isa Absent || push!(_openapi_output, "volumeClaimTemplates" => _openapi_value.volumeclaimtemplates) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetCondition}, value) = _decode(IoK8sApiAppsV1StatefulSetCondition, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiAppsV1StatefulSetCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAppsV1StatefulSetCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetCondition"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetStatus + availablereplicas::Union{Absent,Int32,Nothing} = ABSENT + collisioncount::Union{Absent,Int32,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1StatefulSetCondition}}} = ABSENT + currentreplicas::Union{Absent,Int32,Nothing} = ABSENT + currentrevision::Union{Absent,Nothing,String} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + readyreplicas::Union{Absent,Int32,Nothing} = ABSENT + replicas::Int32 + updaterevision::Union{Absent,Nothing,String} = ABSENT + updatedreplicas::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetStatus}, value) = _decode(IoK8sApiAppsV1StatefulSetStatus, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetStatus") + _openapi_field_availablereplicas = haskey(_openapi_object, "availableReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["availableReplicas"], _openapi_validate) : ABSENT + _openapi_field_collisioncount = haskey(_openapi_object, "collisionCount") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["collisionCount"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAppsV1StatefulSetCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currentreplicas = haskey(_openapi_object, "currentReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["currentReplicas"], _openapi_validate) : ABSENT + _openapi_field_currentrevision = haskey(_openapi_object, "currentRevision") ? _decode(Union{Absent,Nothing,String}, _openapi_object["currentRevision"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_readyreplicas = haskey(_openapi_object, "readyReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["readyReplicas"], _openapi_validate) : ABSENT + _openapi_field_replicas = _decode(Int32, _required(_openapi_object, "replicas", "IoK8sApiAppsV1StatefulSetStatus"), _openapi_validate) + _openapi_field_updaterevision = haskey(_openapi_object, "updateRevision") ? _decode(Union{Absent,Nothing,String}, _openapi_object["updateRevision"], _openapi_validate) : ABSENT + _openapi_field_updatedreplicas = haskey(_openapi_object, "updatedReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["updatedReplicas"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("availableReplicas","collisionCount","conditions","currentReplicas","currentRevision","observedGeneration","readyReplicas","replicas","updateRevision","updatedReplicas") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetStatus(; availablereplicas = _openapi_field_availablereplicas, collisioncount = _openapi_field_collisioncount, conditions = _openapi_field_conditions, currentreplicas = _openapi_field_currentreplicas, currentrevision = _openapi_field_currentrevision, observedgeneration = _openapi_field_observedgeneration, readyreplicas = _openapi_field_readyreplicas, replicas = _openapi_field_replicas, updaterevision = _openapi_field_updaterevision, updatedreplicas = _openapi_field_updatedreplicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.availablereplicas isa Absent || (_openapi_output["availableReplicas"] = _encode(_openapi_value.availablereplicas)) + _openapi_value.collisioncount isa Absent || (_openapi_output["collisionCount"] = _encode(_openapi_value.collisioncount)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currentreplicas isa Absent || (_openapi_output["currentReplicas"] = _encode(_openapi_value.currentreplicas)) + _openapi_value.currentrevision isa Absent || (_openapi_output["currentRevision"] = _encode(_openapi_value.currentrevision)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.readyreplicas isa Absent || (_openapi_output["readyReplicas"] = _encode(_openapi_value.readyreplicas)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.updaterevision isa Absent || (_openapi_output["updateRevision"] = _encode(_openapi_value.updaterevision)) + _openapi_value.updatedreplicas isa Absent || (_openapi_output["updatedReplicas"] = _encode(_openapi_value.updatedreplicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetStatus"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.availablereplicas isa Absent || push!(_openapi_output, "availableReplicas" => _openapi_value.availablereplicas) + _openapi_value.collisioncount isa Absent || push!(_openapi_output, "collisionCount" => _openapi_value.collisioncount) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currentreplicas isa Absent || push!(_openapi_output, "currentReplicas" => _openapi_value.currentreplicas) + _openapi_value.currentrevision isa Absent || push!(_openapi_output, "currentRevision" => _openapi_value.currentrevision) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.readyreplicas isa Absent || push!(_openapi_output, "readyReplicas" => _openapi_value.readyreplicas) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.updaterevision isa Absent || push!(_openapi_output, "updateRevision" => _openapi_value.updaterevision) + _openapi_value.updatedreplicas isa Absent || push!(_openapi_output, "updatedReplicas" => _openapi_value.updatedreplicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSet + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAppsV1StatefulSetSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAppsV1StatefulSetStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSet}, value) = _decode(IoK8sApiAppsV1StatefulSet, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSet}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSet"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSet"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSet") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAppsV1StatefulSetSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAppsV1StatefulSetStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSet(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSet) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSet"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSet"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSet) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAppsV1StatefulSetList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAppsV1StatefulSet}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAppsV1StatefulSetList}, value) = _decode(IoK8sApiAppsV1StatefulSetList, value, true) +function _decode(::Type{IoK8sApiAppsV1StatefulSetList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetList"), _openapi_raw, "decoding IoK8sApiAppsV1StatefulSetList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAppsV1StatefulSetList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAppsV1StatefulSet}}, _required(_openapi_object, "items", "IoK8sApiAppsV1StatefulSetList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAppsV1StatefulSetList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAppsV1StatefulSetList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.apps.v1.StatefulSetList"), _openapi_output, "encoding IoK8sApiAppsV1StatefulSetList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAppsV1StatefulSetList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1ScaleSpec + replicas::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1ScaleSpec}, value) = _decode(IoK8sApiAutoscalingV1ScaleSpec, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1ScaleSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec"), _openapi_raw, "decoding IoK8sApiAutoscalingV1ScaleSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1ScaleSpec") + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("replicas",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1ScaleSpec(; replicas = _openapi_field_replicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1ScaleSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec"), _openapi_output, "encoding IoK8sApiAutoscalingV1ScaleSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1ScaleSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1ScaleStatus + replicas::Int32 + selector::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1ScaleStatus}, value) = _decode(IoK8sApiAutoscalingV1ScaleStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1ScaleStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV1ScaleStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1ScaleStatus") + _openapi_field_replicas = _decode(Int32, _required(_openapi_object, "replicas", "IoK8sApiAutoscalingV1ScaleStatus"), _openapi_validate) + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("replicas","selector") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1ScaleStatus(; replicas = _openapi_field_replicas, selector = _openapi_field_selector, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1ScaleStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV1ScaleStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1ScaleStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1Scale + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAutoscalingV1ScaleSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAutoscalingV1ScaleStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1Scale}, value) = _decode(IoK8sApiAutoscalingV1Scale, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1Scale}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale"), _openapi_raw, "decoding IoK8sApiAutoscalingV1Scale"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1Scale") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAutoscalingV1ScaleSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAutoscalingV1ScaleStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1Scale(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1Scale) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale"), _openapi_output, "encoding IoK8sApiAutoscalingV1Scale"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1Scale) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getappsv1apiresources = ( + id = "getAppsV1APIResources", + method = "GET", + path = "/apis/apps/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getappsv1apiresources(...)\n\nget available resources\n\n`GET /apis/apps/v1/`" +function getappsv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getappsv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1controllerrevisionforallnamespaces = ( + id = "listAppsV1ControllerRevisionForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/controllerrevisions", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1controllerrevisions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1controllerrevisionforallnamespaces(...)\n\nlist or watch objects of kind ControllerRevision\n\n`GET /apis/apps/v1/controllerrevisions`" +function listappsv1controllerrevisionforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1controllerrevisionforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1daemonsetforallnamespaces = ( + id = "listAppsV1DaemonSetForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/daemonsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1daemonsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1daemonsetforallnamespaces(...)\n\nlist or watch objects of kind DaemonSet\n\n`GET /apis/apps/v1/daemonsets`" +function listappsv1daemonsetforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1daemonsetforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1deploymentforallnamespaces = ( + id = "listAppsV1DeploymentForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/deployments", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1deployments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1deploymentforallnamespaces(...)\n\nlist or watch objects of kind Deployment\n\n`GET /apis/apps/v1/deployments`" +function listappsv1deploymentforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1deploymentforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1collectionnamespacedcontrollerrevision = ( + id = "deleteAppsV1CollectionNamespacedControllerRevision", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1collectionnamespacedcontrollerrevision(...)\n\ndelete collection of ControllerRevision\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/controllerrevisions`" +function deleteappsv1collectionnamespacedcontrollerrevision(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteappsv1collectionnamespacedcontrollerrevision, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1namespacedcontrollerrevision = ( + id = "listAppsV1NamespacedControllerRevision", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevisionList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1namespacedcontrollerrevision(...)\n\nlist or watch objects of kind ControllerRevision\n\n`GET /apis/apps/v1/namespaces/{namespace}/controllerrevisions`" +function listappsv1namespacedcontrollerrevision(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1namespacedcontrollerrevision, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createappsv1namespacedcontrollerrevision = ( + id = "createAppsV1NamespacedControllerRevision", + method = "POST", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createappsv1namespacedcontrollerrevision(...)\n\ncreate a ControllerRevision\n\n`POST /apis/apps/v1/namespaces/{namespace}/controllerrevisions`" +function createappsv1namespacedcontrollerrevision(namespace::String, body::IoK8sApiAppsV1ControllerRevision; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createappsv1namespacedcontrollerrevision, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1namespacedcontrollerrevision = ( + id = "deleteAppsV1NamespacedControllerRevision", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1namespacedcontrollerrevision(...)\n\ndelete a ControllerRevision\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}`" +function deleteappsv1namespacedcontrollerrevision(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteappsv1namespacedcontrollerrevision, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedcontrollerrevision = ( + id = "readAppsV1NamespacedControllerRevision", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedcontrollerrevision(...)\n\nread the specified ControllerRevision\n\n`GET /apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}`" +function readappsv1namespacedcontrollerrevision(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readappsv1namespacedcontrollerrevision, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedcontrollerrevision = ( + id = "patchAppsV1NamespacedControllerRevision", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedcontrollerrevision(...)\n\npartially update the specified ControllerRevision\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}`" +function patchappsv1namespacedcontrollerrevision(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedcontrollerrevision, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedcontrollerrevision = ( + id = "replaceAppsV1NamespacedControllerRevision", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ControllerRevision, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1controllerrevisions~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedcontrollerrevision(...)\n\nreplace the specified ControllerRevision\n\n`PUT /apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}`" +function replaceappsv1namespacedcontrollerrevision(namespace::String, name::String, body::IoK8sApiAppsV1ControllerRevision; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedcontrollerrevision, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1collectionnamespaceddaemonset = ( + id = "deleteAppsV1CollectionNamespacedDaemonSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1collectionnamespaceddaemonset(...)\n\ndelete collection of DaemonSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/daemonsets`" +function deleteappsv1collectionnamespaceddaemonset(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteappsv1collectionnamespaceddaemonset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1namespaceddaemonset = ( + id = "listAppsV1NamespacedDaemonSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1namespaceddaemonset(...)\n\nlist or watch objects of kind DaemonSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/daemonsets`" +function listappsv1namespaceddaemonset(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1namespaceddaemonset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createappsv1namespaceddaemonset = ( + id = "createAppsV1NamespacedDaemonSet", + method = "POST", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createappsv1namespaceddaemonset(...)\n\ncreate a DaemonSet\n\n`POST /apis/apps/v1/namespaces/{namespace}/daemonsets`" +function createappsv1namespaceddaemonset(namespace::String, body::IoK8sApiAppsV1DaemonSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createappsv1namespaceddaemonset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1namespaceddaemonset = ( + id = "deleteAppsV1NamespacedDaemonSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1namespaceddaemonset(...)\n\ndelete a DaemonSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}`" +function deleteappsv1namespaceddaemonset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteappsv1namespaceddaemonset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespaceddaemonset = ( + id = "readAppsV1NamespacedDaemonSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespaceddaemonset(...)\n\nread the specified DaemonSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}`" +function readappsv1namespaceddaemonset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readappsv1namespaceddaemonset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespaceddaemonset = ( + id = "patchAppsV1NamespacedDaemonSet", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespaceddaemonset(...)\n\npartially update the specified DaemonSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}`" +function patchappsv1namespaceddaemonset(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespaceddaemonset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespaceddaemonset = ( + id = "replaceAppsV1NamespacedDaemonSet", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespaceddaemonset(...)\n\nreplace the specified DaemonSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}`" +function replaceappsv1namespaceddaemonset(namespace::String, name::String, body::IoK8sApiAppsV1DaemonSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespaceddaemonset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespaceddaemonsetstatus = ( + id = "readAppsV1NamespacedDaemonSetStatus", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespaceddaemonsetstatus(...)\n\nread status of the specified DaemonSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status`" +function readappsv1namespaceddaemonsetstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespaceddaemonsetstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespaceddaemonsetstatus = ( + id = "patchAppsV1NamespacedDaemonSetStatus", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespaceddaemonsetstatus(...)\n\npartially update status of the specified DaemonSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status`" +function patchappsv1namespaceddaemonsetstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespaceddaemonsetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespaceddaemonsetstatus = ( + id = "replaceAppsV1NamespacedDaemonSetStatus", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DaemonSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1daemonsets~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespaceddaemonsetstatus(...)\n\nreplace status of the specified DaemonSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status`" +function replaceappsv1namespaceddaemonsetstatus(namespace::String, name::String, body::IoK8sApiAppsV1DaemonSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespaceddaemonsetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1collectionnamespaceddeployment = ( + id = "deleteAppsV1CollectionNamespacedDeployment", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/deployments", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1collectionnamespaceddeployment(...)\n\ndelete collection of Deployment\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/deployments`" +function deleteappsv1collectionnamespaceddeployment(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteappsv1collectionnamespaceddeployment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1namespaceddeployment = ( + id = "listAppsV1NamespacedDeployment", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/deployments", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1DeploymentList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1namespaceddeployment(...)\n\nlist or watch objects of kind Deployment\n\n`GET /apis/apps/v1/namespaces/{namespace}/deployments`" +function listappsv1namespaceddeployment(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1namespaceddeployment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createappsv1namespaceddeployment = ( + id = "createAppsV1NamespacedDeployment", + method = "POST", + path = "/apis/apps/v1/namespaces/{namespace}/deployments", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createappsv1namespaceddeployment(...)\n\ncreate a Deployment\n\n`POST /apis/apps/v1/namespaces/{namespace}/deployments`" +function createappsv1namespaceddeployment(namespace::String, body::IoK8sApiAppsV1Deployment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createappsv1namespaceddeployment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1namespaceddeployment = ( + id = "deleteAppsV1NamespacedDeployment", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1namespaceddeployment(...)\n\ndelete a Deployment\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/deployments/{name}`" +function deleteappsv1namespaceddeployment(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteappsv1namespaceddeployment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespaceddeployment = ( + id = "readAppsV1NamespacedDeployment", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespaceddeployment(...)\n\nread the specified Deployment\n\n`GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}`" +function readappsv1namespaceddeployment(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readappsv1namespaceddeployment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespaceddeployment = ( + id = "patchAppsV1NamespacedDeployment", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespaceddeployment(...)\n\npartially update the specified Deployment\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/deployments/{name}`" +function patchappsv1namespaceddeployment(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespaceddeployment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespaceddeployment = ( + id = "replaceAppsV1NamespacedDeployment", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespaceddeployment(...)\n\nreplace the specified Deployment\n\n`PUT /apis/apps/v1/namespaces/{namespace}/deployments/{name}`" +function replaceappsv1namespaceddeployment(namespace::String, name::String, body::IoK8sApiAppsV1Deployment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespaceddeployment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespaceddeploymentscale = ( + id = "readAppsV1NamespacedDeploymentScale", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespaceddeploymentscale(...)\n\nread scale of the specified Deployment\n\n`GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale`" +function readappsv1namespaceddeploymentscale(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespaceddeploymentscale, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespaceddeploymentscale = ( + id = "patchAppsV1NamespacedDeploymentScale", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespaceddeploymentscale(...)\n\npartially update scale of the specified Deployment\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale`" +function patchappsv1namespaceddeploymentscale(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespaceddeploymentscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespaceddeploymentscale = ( + id = "replaceAppsV1NamespacedDeploymentScale", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1scale/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespaceddeploymentscale(...)\n\nreplace scale of the specified Deployment\n\n`PUT /apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale`" +function replaceappsv1namespaceddeploymentscale(namespace::String, name::String, body::IoK8sApiAutoscalingV1Scale; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespaceddeploymentscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespaceddeploymentstatus = ( + id = "readAppsV1NamespacedDeploymentStatus", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespaceddeploymentstatus(...)\n\nread status of the specified Deployment\n\n`GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}/status`" +function readappsv1namespaceddeploymentstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespaceddeploymentstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespaceddeploymentstatus = ( + id = "patchAppsV1NamespacedDeploymentStatus", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespaceddeploymentstatus(...)\n\npartially update status of the specified Deployment\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/deployments/{name}/status`" +function patchappsv1namespaceddeploymentstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespaceddeploymentstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespaceddeploymentstatus = ( + id = "replaceAppsV1NamespacedDeploymentStatus", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1Deployment, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1deployments~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespaceddeploymentstatus(...)\n\nreplace status of the specified Deployment\n\n`PUT /apis/apps/v1/namespaces/{namespace}/deployments/{name}/status`" +function replaceappsv1namespaceddeploymentstatus(namespace::String, name::String, body::IoK8sApiAppsV1Deployment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespaceddeploymentstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1collectionnamespacedreplicaset = ( + id = "deleteAppsV1CollectionNamespacedReplicaSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1collectionnamespacedreplicaset(...)\n\ndelete collection of ReplicaSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/replicasets`" +function deleteappsv1collectionnamespacedreplicaset(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteappsv1collectionnamespacedreplicaset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1namespacedreplicaset = ( + id = "listAppsV1NamespacedReplicaSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1namespacedreplicaset(...)\n\nlist or watch objects of kind ReplicaSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/replicasets`" +function listappsv1namespacedreplicaset(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1namespacedreplicaset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createappsv1namespacedreplicaset = ( + id = "createAppsV1NamespacedReplicaSet", + method = "POST", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createappsv1namespacedreplicaset(...)\n\ncreate a ReplicaSet\n\n`POST /apis/apps/v1/namespaces/{namespace}/replicasets`" +function createappsv1namespacedreplicaset(namespace::String, body::IoK8sApiAppsV1ReplicaSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createappsv1namespacedreplicaset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1namespacedreplicaset = ( + id = "deleteAppsV1NamespacedReplicaSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1namespacedreplicaset(...)\n\ndelete a ReplicaSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/replicasets/{name}`" +function deleteappsv1namespacedreplicaset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteappsv1namespacedreplicaset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedreplicaset = ( + id = "readAppsV1NamespacedReplicaSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedreplicaset(...)\n\nread the specified ReplicaSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/replicasets/{name}`" +function readappsv1namespacedreplicaset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readappsv1namespacedreplicaset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedreplicaset = ( + id = "patchAppsV1NamespacedReplicaSet", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedreplicaset(...)\n\npartially update the specified ReplicaSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/replicasets/{name}`" +function patchappsv1namespacedreplicaset(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedreplicaset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedreplicaset = ( + id = "replaceAppsV1NamespacedReplicaSet", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedreplicaset(...)\n\nreplace the specified ReplicaSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/replicasets/{name}`" +function replaceappsv1namespacedreplicaset(namespace::String, name::String, body::IoK8sApiAppsV1ReplicaSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedreplicaset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedreplicasetscale = ( + id = "readAppsV1NamespacedReplicaSetScale", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedreplicasetscale(...)\n\nread scale of the specified ReplicaSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale`" +function readappsv1namespacedreplicasetscale(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespacedreplicasetscale, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedreplicasetscale = ( + id = "patchAppsV1NamespacedReplicaSetScale", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedreplicasetscale(...)\n\npartially update scale of the specified ReplicaSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale`" +function patchappsv1namespacedreplicasetscale(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedreplicasetscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedreplicasetscale = ( + id = "replaceAppsV1NamespacedReplicaSetScale", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1scale/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedreplicasetscale(...)\n\nreplace scale of the specified ReplicaSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale`" +function replaceappsv1namespacedreplicasetscale(namespace::String, name::String, body::IoK8sApiAutoscalingV1Scale; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedreplicasetscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedreplicasetstatus = ( + id = "readAppsV1NamespacedReplicaSetStatus", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedreplicasetstatus(...)\n\nread status of the specified ReplicaSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status`" +function readappsv1namespacedreplicasetstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespacedreplicasetstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedreplicasetstatus = ( + id = "patchAppsV1NamespacedReplicaSetStatus", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedreplicasetstatus(...)\n\npartially update status of the specified ReplicaSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status`" +function patchappsv1namespacedreplicasetstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedreplicasetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedreplicasetstatus = ( + id = "replaceAppsV1NamespacedReplicaSetStatus", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1replicasets~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedreplicasetstatus(...)\n\nreplace status of the specified ReplicaSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status`" +function replaceappsv1namespacedreplicasetstatus(namespace::String, name::String, body::IoK8sApiAppsV1ReplicaSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedreplicasetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1collectionnamespacedstatefulset = ( + id = "deleteAppsV1CollectionNamespacedStatefulSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1collectionnamespacedstatefulset(...)\n\ndelete collection of StatefulSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/statefulsets`" +function deleteappsv1collectionnamespacedstatefulset(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteappsv1collectionnamespacedstatefulset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1namespacedstatefulset = ( + id = "listAppsV1NamespacedStatefulSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1namespacedstatefulset(...)\n\nlist or watch objects of kind StatefulSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/statefulsets`" +function listappsv1namespacedstatefulset(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1namespacedstatefulset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createappsv1namespacedstatefulset = ( + id = "createAppsV1NamespacedStatefulSet", + method = "POST", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createappsv1namespacedstatefulset(...)\n\ncreate a StatefulSet\n\n`POST /apis/apps/v1/namespaces/{namespace}/statefulsets`" +function createappsv1namespacedstatefulset(namespace::String, body::IoK8sApiAppsV1StatefulSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createappsv1namespacedstatefulset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteappsv1namespacedstatefulset = ( + id = "deleteAppsV1NamespacedStatefulSet", + method = "DELETE", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteappsv1namespacedstatefulset(...)\n\ndelete a StatefulSet\n\n`DELETE /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}`" +function deleteappsv1namespacedstatefulset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteappsv1namespacedstatefulset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedstatefulset = ( + id = "readAppsV1NamespacedStatefulSet", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedstatefulset(...)\n\nread the specified StatefulSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}`" +function readappsv1namespacedstatefulset(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readappsv1namespacedstatefulset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedstatefulset = ( + id = "patchAppsV1NamespacedStatefulSet", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedstatefulset(...)\n\npartially update the specified StatefulSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}`" +function patchappsv1namespacedstatefulset(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedstatefulset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedstatefulset = ( + id = "replaceAppsV1NamespacedStatefulSet", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedstatefulset(...)\n\nreplace the specified StatefulSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}`" +function replaceappsv1namespacedstatefulset(namespace::String, name::String, body::IoK8sApiAppsV1StatefulSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedstatefulset, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedstatefulsetscale = ( + id = "readAppsV1NamespacedStatefulSetScale", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedstatefulsetscale(...)\n\nread scale of the specified StatefulSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale`" +function readappsv1namespacedstatefulsetscale(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespacedstatefulsetscale, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedstatefulsetscale = ( + id = "patchAppsV1NamespacedStatefulSetScale", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedstatefulsetscale(...)\n\npartially update scale of the specified StatefulSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale`" +function patchappsv1namespacedstatefulsetscale(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedstatefulsetscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedstatefulsetscale = ( + id = "replaceAppsV1NamespacedStatefulSetScale", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1scale/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedstatefulsetscale(...)\n\nreplace scale of the specified StatefulSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale`" +function replaceappsv1namespacedstatefulsetscale(namespace::String, name::String, body::IoK8sApiAutoscalingV1Scale; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedstatefulsetscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readappsv1namespacedstatefulsetstatus = ( + id = "readAppsV1NamespacedStatefulSetStatus", + method = "GET", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readappsv1namespacedstatefulsetstatus(...)\n\nread status of the specified StatefulSet\n\n`GET /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status`" +function readappsv1namespacedstatefulsetstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readappsv1namespacedstatefulsetstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchappsv1namespacedstatefulsetstatus = ( + id = "patchAppsV1NamespacedStatefulSetStatus", + method = "PATCH", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchappsv1namespacedstatefulsetstatus(...)\n\npartially update status of the specified StatefulSet\n\n`PATCH /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status`" +function patchappsv1namespacedstatefulsetstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchappsv1namespacedstatefulsetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceappsv1namespacedstatefulsetstatus = ( + id = "replaceAppsV1NamespacedStatefulSetStatus", + method = "PUT", + path = "/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSet, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1namespaces~1{namespace}~1statefulsets~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceappsv1namespacedstatefulsetstatus(...)\n\nreplace status of the specified StatefulSet\n\n`PUT /apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status`" +function replaceappsv1namespacedstatefulsetstatus(namespace::String, name::String, body::IoK8sApiAppsV1StatefulSet; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceappsv1namespacedstatefulsetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1replicasetforallnamespaces = ( + id = "listAppsV1ReplicaSetForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/replicasets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1ReplicaSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1replicasets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1replicasetforallnamespaces(...)\n\nlist or watch objects of kind ReplicaSet\n\n`GET /apis/apps/v1/replicasets`" +function listappsv1replicasetforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1replicasetforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listappsv1statefulsetforallnamespaces = ( + id = "listAppsV1StatefulSetForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/statefulsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAppsV1StatefulSetList, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1statefulsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listappsv1statefulsetforallnamespaces(...)\n\nlist or watch objects of kind StatefulSet\n\n`GET /apis/apps/v1/statefulsets`" +function listappsv1statefulsetforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listappsv1statefulsetforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1controllerrevisionlistforallnamespaces = ( + id = "watchAppsV1ControllerRevisionListForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/watch/controllerrevisions", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1controllerrevisions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1controllerrevisionlistforallnamespaces(...)\n\nwatch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/controllerrevisions`" +function watchappsv1controllerrevisionlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1controllerrevisionlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1daemonsetlistforallnamespaces = ( + id = "watchAppsV1DaemonSetListForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/watch/daemonsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1daemonsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1daemonsetlistforallnamespaces(...)\n\nwatch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/daemonsets`" +function watchappsv1daemonsetlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1daemonsetlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1deploymentlistforallnamespaces = ( + id = "watchAppsV1DeploymentListForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/watch/deployments", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1deployments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1deploymentlistforallnamespaces(...)\n\nwatch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/deployments`" +function watchappsv1deploymentlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1deploymentlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedcontrollerrevisionlist = ( + id = "watchAppsV1NamespacedControllerRevisionList", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedcontrollerrevisionlist(...)\n\nwatch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions`" +function watchappsv1namespacedcontrollerrevisionlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedcontrollerrevisionlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedcontrollerrevision = ( + id = "watchAppsV1NamespacedControllerRevision", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1controllerrevisions~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedcontrollerrevision(...)\n\nwatch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}`" +function watchappsv1namespacedcontrollerrevision(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedcontrollerrevision, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespaceddaemonsetlist = ( + id = "watchAppsV1NamespacedDaemonSetList", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespaceddaemonsetlist(...)\n\nwatch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/daemonsets`" +function watchappsv1namespaceddaemonsetlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespaceddaemonsetlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespaceddaemonset = ( + id = "watchAppsV1NamespacedDaemonSet", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1daemonsets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespaceddaemonset(...)\n\nwatch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/daemonsets/{name}`" +function watchappsv1namespaceddaemonset(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespaceddaemonset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespaceddeploymentlist = ( + id = "watchAppsV1NamespacedDeploymentList", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/deployments", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespaceddeploymentlist(...)\n\nwatch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/deployments`" +function watchappsv1namespaceddeploymentlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespaceddeploymentlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespaceddeployment = ( + id = "watchAppsV1NamespacedDeployment", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1deployments~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespaceddeployment(...)\n\nwatch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}`" +function watchappsv1namespaceddeployment(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespaceddeployment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedreplicasetlist = ( + id = "watchAppsV1NamespacedReplicaSetList", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/replicasets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedreplicasetlist(...)\n\nwatch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/replicasets`" +function watchappsv1namespacedreplicasetlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedreplicasetlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedreplicaset = ( + id = "watchAppsV1NamespacedReplicaSet", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1replicasets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedreplicaset(...)\n\nwatch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/replicasets/{name}`" +function watchappsv1namespacedreplicaset(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedreplicaset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedstatefulsetlist = ( + id = "watchAppsV1NamespacedStatefulSetList", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedstatefulsetlist(...)\n\nwatch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/statefulsets`" +function watchappsv1namespacedstatefulsetlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedstatefulsetlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1namespacedstatefulset = ( + id = "watchAppsV1NamespacedStatefulSet", + method = "GET", + path = "/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1namespaces~1{namespace}~1statefulsets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1namespacedstatefulset(...)\n\nwatch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}`" +function watchappsv1namespacedstatefulset(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1namespacedstatefulset, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1replicasetlistforallnamespaces = ( + id = "watchAppsV1ReplicaSetListForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/watch/replicasets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1replicasets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1replicasetlistforallnamespaces(...)\n\nwatch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/replicasets`" +function watchappsv1replicasetlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1replicasetlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchappsv1statefulsetlistforallnamespaces = ( + id = "watchAppsV1StatefulSetListForAllNamespaces", + method = "GET", + path = "/apis/apps/v1/watch/statefulsets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-5515bf60f3c4dc59e379.json", pointer = "/paths/~1apis~1apps~1v1~1watch~1statefulsets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchappsv1statefulsetlistforallnamespaces(...)\n\nwatch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/apps/v1/watch/statefulsets`" +function watchappsv1statefulsetlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchappsv1statefulsetlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sAppsV1 diff --git a/src/ApiImpl/generated/K8sAutoscalingV1.jl b/src/ApiImpl/generated/K8sAutoscalingV1.jl new file mode 100644 index 00000000..af09cf11 --- /dev/null +++ b/src/ApiImpl/generated/K8sAutoscalingV1.jl @@ -0,0 +1,1795 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sAutoscalingV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", retrieval = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.autoscaling.v1.CrossVersionObjectReference\":{\"description\":\"CrossVersionObjectReference contains enough information to let you identify the referred resource.\",\"properties\":{\"apiVersion\":{\"description\":\"apiVersion is the API version of the referent\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\":{\"description\":\"configuration of a horizontal pod autoscaler.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}]},\"io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\":{\"description\":\"list of horizontal pod autoscaler objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of horizontal pod autoscaler objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscalerList\",\"version\":\"v1\"}]},\"io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec\":{\"description\":\"specification of a horizontal pod autoscaler.\",\"properties\":{\"maxReplicas\":{\"default\":0,\"description\":\"maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.\",\"format\":\"int32\",\"type\":\"integer\"},\"minReplicas\":{\"description\":\"minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.\",\"format\":\"int32\",\"type\":\"integer\"},\"scaleTargetRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference\"},\"targetCPUUtilizationPercentage\":{\"description\":\"targetCPUUtilizationPercentage is the target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"scaleTargetRef\",\"maxReplicas\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus\":{\"description\":\"current status of a horizontal pod autoscaler\",\"properties\":{\"currentCPUUtilizationPercentage\":{\"description\":\"currentCPUUtilizationPercentage is the current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU.\",\"format\":\"int32\",\"type\":\"integer\"},\"currentReplicas\":{\"default\":0,\"description\":\"currentReplicas is the current number of replicas of pods managed by this autoscaler.\",\"format\":\"int32\",\"type\":\"integer\"},\"desiredReplicas\":{\"default\":0,\"description\":\"desiredReplicas is the desired number of replicas of pods managed by this autoscaler.\",\"format\":\"int32\",\"type\":\"integer\"},\"lastScaleTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"observedGeneration\":{\"description\":\"observedGeneration is the most recent generation observed by this autoscaler.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"currentReplicas\",\"desiredReplicas\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/autoscaling/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getAutoscalingV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"]}},\"/apis/autoscaling/v1/horizontalpodautoscalers\":{\"get\":{\"description\":\"list or watch objects of kind HorizontalPodAutoscaler\",\"operationId\":\"listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers\":{\"delete\":{\"description\":\"delete collection of HorizontalPodAutoscaler\",\"operationId\":\"deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind HorizontalPodAutoscaler\",\"operationId\":\"listAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a HorizontalPodAutoscaler\",\"operationId\":\"createAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}}},\"/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}\":{\"delete\":{\"description\":\"delete a HorizontalPodAutoscaler\",\"operationId\":\"deleteAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified HorizontalPodAutoscaler\",\"operationId\":\"readAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified HorizontalPodAutoscaler\",\"operationId\":\"patchAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified HorizontalPodAutoscaler\",\"operationId\":\"replaceAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}}},\"/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status\":{\"get\":{\"description\":\"read status of the specified HorizontalPodAutoscaler\",\"operationId\":\"readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified HorizontalPodAutoscaler\",\"operationId\":\"patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified HorizontalPodAutoscaler\",\"operationId\":\"replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}}},\"/apis/autoscaling/v1/watch/horizontalpodautoscalers\":{\"get\":{\"description\":\"watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers\":{\"get\":{\"description\":\"watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAutoscalingV1NamespacedHorizontalPodAutoscalerList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAutoscalingV1NamespacedHorizontalPodAutoscaler\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3a3078c2ac937a364459.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiAutoscalingV1CrossVersionObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1CrossVersionObjectReference}, value) = _decode(IoK8sApiAutoscalingV1CrossVersionObjectReference, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1CrossVersionObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference"), _openapi_raw, "decoding IoK8sApiAutoscalingV1CrossVersionObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1CrossVersionObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiAutoscalingV1CrossVersionObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV1CrossVersionObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1CrossVersionObjectReference(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1CrossVersionObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.CrossVersionObjectReference"), _openapi_output, "encoding IoK8sApiAutoscalingV1CrossVersionObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1CrossVersionObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec + maxreplicas::Int32 + minreplicas::Union{Absent,Int32,Nothing} = ABSENT + scaletargetref::IoK8sApiAutoscalingV1CrossVersionObjectReference + targetcpuutilizationpercentage::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec}, value) = _decode(IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec"), _openapi_raw, "decoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec") + _openapi_field_maxreplicas = _decode(Int32, _required(_openapi_object, "maxReplicas", "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec"), _openapi_validate) + _openapi_field_minreplicas = haskey(_openapi_object, "minReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReplicas"], _openapi_validate) : ABSENT + _openapi_field_scaletargetref = _decode(IoK8sApiAutoscalingV1CrossVersionObjectReference, _required(_openapi_object, "scaleTargetRef", "IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec"), _openapi_validate) + _openapi_field_targetcpuutilizationpercentage = haskey(_openapi_object, "targetCPUUtilizationPercentage") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["targetCPUUtilizationPercentage"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("maxReplicas","minReplicas","scaleTargetRef","targetCPUUtilizationPercentage") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec(; maxreplicas = _openapi_field_maxreplicas, minreplicas = _openapi_field_minreplicas, scaletargetref = _openapi_field_scaletargetref, targetcpuutilizationpercentage = _openapi_field_targetcpuutilizationpercentage, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.maxreplicas isa Absent || (_openapi_output["maxReplicas"] = _encode(_openapi_value.maxreplicas)) + _openapi_value.minreplicas isa Absent || (_openapi_output["minReplicas"] = _encode(_openapi_value.minreplicas)) + _openapi_value.scaletargetref isa Absent || (_openapi_output["scaleTargetRef"] = _encode(_openapi_value.scaletargetref)) + _openapi_value.targetcpuutilizationpercentage isa Absent || (_openapi_output["targetCPUUtilizationPercentage"] = _encode(_openapi_value.targetcpuutilizationpercentage)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec"), _openapi_output, "encoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.maxreplicas isa Absent || push!(_openapi_output, "maxReplicas" => _openapi_value.maxreplicas) + _openapi_value.minreplicas isa Absent || push!(_openapi_output, "minReplicas" => _openapi_value.minreplicas) + _openapi_value.scaletargetref isa Absent || push!(_openapi_output, "scaleTargetRef" => _openapi_value.scaletargetref) + _openapi_value.targetcpuutilizationpercentage isa Absent || push!(_openapi_output, "targetCPUUtilizationPercentage" => _openapi_value.targetcpuutilizationpercentage) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus + currentcpuutilizationpercentage::Union{Absent,Int32,Nothing} = ABSENT + currentreplicas::Int32 + desiredreplicas::Int32 + lastscaletime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus}, value) = _decode(IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus") + _openapi_field_currentcpuutilizationpercentage = haskey(_openapi_object, "currentCPUUtilizationPercentage") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["currentCPUUtilizationPercentage"], _openapi_validate) : ABSENT + _openapi_field_currentreplicas = _decode(Int32, _required(_openapi_object, "currentReplicas", "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus"), _openapi_validate) + _openapi_field_desiredreplicas = _decode(Int32, _required(_openapi_object, "desiredReplicas", "IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus"), _openapi_validate) + _openapi_field_lastscaletime = haskey(_openapi_object, "lastScaleTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastScaleTime"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("currentCPUUtilizationPercentage","currentReplicas","desiredReplicas","lastScaleTime","observedGeneration") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus(; currentcpuutilizationpercentage = _openapi_field_currentcpuutilizationpercentage, currentreplicas = _openapi_field_currentreplicas, desiredreplicas = _openapi_field_desiredreplicas, lastscaletime = _openapi_field_lastscaletime, observedgeneration = _openapi_field_observedgeneration, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.currentcpuutilizationpercentage isa Absent || (_openapi_output["currentCPUUtilizationPercentage"] = _encode(_openapi_value.currentcpuutilizationpercentage)) + _openapi_value.currentreplicas isa Absent || (_openapi_output["currentReplicas"] = _encode(_openapi_value.currentreplicas)) + _openapi_value.desiredreplicas isa Absent || (_openapi_output["desiredReplicas"] = _encode(_openapi_value.desiredreplicas)) + _openapi_value.lastscaletime isa Absent || (_openapi_output["lastScaleTime"] = _encode(_openapi_value.lastscaletime)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.currentcpuutilizationpercentage isa Absent || push!(_openapi_output, "currentCPUUtilizationPercentage" => _openapi_value.currentcpuutilizationpercentage) + _openapi_value.currentreplicas isa Absent || push!(_openapi_output, "currentReplicas" => _openapi_value.currentreplicas) + _openapi_value.desiredreplicas isa Absent || push!(_openapi_output, "desiredReplicas" => _openapi_value.desiredreplicas) + _openapi_value.lastscaletime isa Absent || push!(_openapi_output, "lastScaleTime" => _openapi_value.lastscaletime) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1HorizontalPodAutoscaler + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscaler}, value) = _decode(IoK8sApiAutoscalingV1HorizontalPodAutoscaler, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscaler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler"), _openapi_raw, "decoding IoK8sApiAutoscalingV1HorizontalPodAutoscaler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1HorizontalPodAutoscaler") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAutoscalingV1HorizontalPodAutoscalerSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAutoscalingV1HorizontalPodAutoscalerStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1HorizontalPodAutoscaler(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscaler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler"), _openapi_output, "encoding IoK8sApiAutoscalingV1HorizontalPodAutoscaler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscaler) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1HorizontalPodAutoscalerList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAutoscalingV1HorizontalPodAutoscaler}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerList}, value) = _decode(IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1HorizontalPodAutoscalerList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList"), _openapi_raw, "decoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1HorizontalPodAutoscalerList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAutoscalingV1HorizontalPodAutoscaler}}, _required(_openapi_object, "items", "IoK8sApiAutoscalingV1HorizontalPodAutoscalerList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1HorizontalPodAutoscalerList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList"), _openapi_output, "encoding IoK8sApiAutoscalingV1HorizontalPodAutoscalerList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1HorizontalPodAutoscalerList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getautoscalingv1apiresources = ( + id = "getAutoscalingV1APIResources", + method = "GET", + path = "/apis/autoscaling/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getautoscalingv1apiresources(...)\n\nget available resources\n\n`GET /apis/autoscaling/v1/`" +function getautoscalingv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getautoscalingv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listautoscalingv1horizontalpodautoscalerforallnamespaces = ( + id = "listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces", + method = "GET", + path = "/apis/autoscaling/v1/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listautoscalingv1horizontalpodautoscalerforallnamespaces(...)\n\nlist or watch objects of kind HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v1/horizontalpodautoscalers`" +function listautoscalingv1horizontalpodautoscalerforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listautoscalingv1horizontalpodautoscalerforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteautoscalingv1collectionnamespacedhorizontalpodautoscaler = ( + id = "deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler", + method = "DELETE", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteautoscalingv1collectionnamespacedhorizontalpodautoscaler(...)\n\ndelete collection of HorizontalPodAutoscaler\n\n`DELETE /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers`" +function deleteautoscalingv1collectionnamespacedhorizontalpodautoscaler(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteautoscalingv1collectionnamespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "listAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listautoscalingv1namespacedhorizontalpodautoscaler(...)\n\nlist or watch objects of kind HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers`" +function listautoscalingv1namespacedhorizontalpodautoscaler(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "createAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "POST", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createautoscalingv1namespacedhorizontalpodautoscaler(...)\n\ncreate a HorizontalPodAutoscaler\n\n`POST /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers`" +function createautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "deleteAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "DELETE", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteautoscalingv1namespacedhorizontalpodautoscaler(...)\n\ndelete a HorizontalPodAutoscaler\n\n`DELETE /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function deleteautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "readAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readautoscalingv1namespacedhorizontalpodautoscaler(...)\n\nread the specified HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function readautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "patchAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "PATCH", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchautoscalingv1namespacedhorizontalpodautoscaler(...)\n\npartially update the specified HorizontalPodAutoscaler\n\n`PATCH /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function patchautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "replaceAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "PUT", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceautoscalingv1namespacedhorizontalpodautoscaler(...)\n\nreplace the specified HorizontalPodAutoscaler\n\n`PUT /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function replaceautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, name::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readautoscalingv1namespacedhorizontalpodautoscalerstatus = ( + id = "readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + method = "GET", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readautoscalingv1namespacedhorizontalpodautoscalerstatus(...)\n\nread status of the specified HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function readautoscalingv1namespacedhorizontalpodautoscalerstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readautoscalingv1namespacedhorizontalpodautoscalerstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchautoscalingv1namespacedhorizontalpodautoscalerstatus = ( + id = "patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + method = "PATCH", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchautoscalingv1namespacedhorizontalpodautoscalerstatus(...)\n\npartially update status of the specified HorizontalPodAutoscaler\n\n`PATCH /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function patchautoscalingv1namespacedhorizontalpodautoscalerstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchautoscalingv1namespacedhorizontalpodautoscalerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceautoscalingv1namespacedhorizontalpodautoscalerstatus = ( + id = "replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus", + method = "PUT", + path = "/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceautoscalingv1namespacedhorizontalpodautoscalerstatus(...)\n\nreplace status of the specified HorizontalPodAutoscaler\n\n`PUT /apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function replaceautoscalingv1namespacedhorizontalpodautoscalerstatus(namespace::String, name::String, body::IoK8sApiAutoscalingV1HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceautoscalingv1namespacedhorizontalpodautoscalerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv1horizontalpodautoscalerlistforallnamespaces = ( + id = "watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces", + method = "GET", + path = "/apis/autoscaling/v1/watch/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv1horizontalpodautoscalerlistforallnamespaces(...)\n\nwatch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/autoscaling/v1/watch/horizontalpodautoscalers`" +function watchautoscalingv1horizontalpodautoscalerlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv1horizontalpodautoscalerlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv1namespacedhorizontalpodautoscalerlist = ( + id = "watchAutoscalingV1NamespacedHorizontalPodAutoscalerList", + method = "GET", + path = "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv1namespacedhorizontalpodautoscalerlist(...)\n\nwatch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers`" +function watchautoscalingv1namespacedhorizontalpodautoscalerlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv1namespacedhorizontalpodautoscalerlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv1namespacedhorizontalpodautoscaler = ( + id = "watchAutoscalingV1NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3a3078c2ac937a364459.json", pointer = "/paths/~1apis~1autoscaling~1v1~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv1namespacedhorizontalpodautoscaler(...)\n\nwatch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function watchautoscalingv1namespacedhorizontalpodautoscaler(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv1namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sAutoscalingV1 diff --git a/src/ApiImpl/generated/K8sAutoscalingV2.jl b/src/ApiImpl/generated/K8sAutoscalingV2.jl new file mode 100644 index 00000000..a4ae7ea8 --- /dev/null +++ b/src/ApiImpl/generated/K8sAutoscalingV2.jl @@ -0,0 +1,2748 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sAutoscalingV2 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", retrieval = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.autoscaling.v2.ContainerResourceMetricSource\":{\"description\":\"ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \\\"pods\\\" source. Only one \\\"target\\\" type should be set.\",\"properties\":{\"container\":{\"default\":\"\",\"description\":\"container is the name of the container in the pods of the scaling target\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of the resource in question.\",\"type\":\"string\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget\"}},\"required\":[\"name\",\"target\",\"container\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus\":{\"description\":\"ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \\\"pods\\\" source.\",\"properties\":{\"container\":{\"default\":\"\",\"description\":\"container is the name of the container in the pods of the scaling target\",\"type\":\"string\"},\"current\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of the resource in question.\",\"type\":\"string\"}},\"required\":[\"name\",\"current\",\"container\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.CrossVersionObjectReference\":{\"description\":\"CrossVersionObjectReference contains enough information to let you identify the referred resource.\",\"properties\":{\"apiVersion\":{\"description\":\"apiVersion is the API version of the referent\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of the referent; More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ExternalMetricSource\":{\"description\":\"ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).\",\"properties\":{\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget\"}},\"required\":[\"metric\",\"target\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ExternalMetricStatus\":{\"description\":\"ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.\",\"properties\":{\"current\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus\"},\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"}},\"required\":[\"metric\",\"current\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HPAScalingPolicy\":{\"description\":\"HPAScalingPolicy is a single policy which must hold true for a specified past interval.\",\"properties\":{\"periodSeconds\":{\"default\":0,\"description\":\"periodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min).\",\"format\":\"int32\",\"type\":\"integer\"},\"type\":{\"default\":\"\",\"description\":\"type is used to specify the scaling policy.\",\"type\":\"string\"},\"value\":{\"default\":0,\"description\":\"value contains the amount of change which is permitted by the policy. It must be greater than zero\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"type\",\"value\",\"periodSeconds\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HPAScalingRules\":{\"description\":\"HPAScalingRules configures the scaling behavior for one direction via scaling Policy Rules and a configurable metric tolerance.\\n\\nScaling Policy Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen.\\n\\nThe tolerance is applied to the metric values and prevents scaling too eagerly for small metric variations. (Note that setting a tolerance requires the beta HPAConfigurableTolerance feature gate to be enabled.)\",\"properties\":{\"policies\":{\"description\":\"policies is a list of potential scaling polices which can be used during scaling. If not set, use the default values: - For scale up: allow doubling the number of pods, or an absolute change of 4 pods in a 15s window. - For scale down: allow all pods to be removed in a 15s window.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"selectPolicy\":{\"description\":\"selectPolicy is used to specify which policy should be used. If not set, the default value Max is used.\",\"type\":\"string\"},\"stabilizationWindowSeconds\":{\"description\":\"stabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long).\",\"format\":\"int32\",\"type\":\"integer\"},\"tolerance\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\":{\"description\":\"HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}]},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior\":{\"description\":\"HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively).\",\"properties\":{\"scaleDown\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules\"},\"scaleUp\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition\":{\"description\":\"HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message is a human-readable explanation containing details about the transition\",\"type\":\"string\"},\"reason\":{\"description\":\"reason is the reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status is the status of the condition (True, False, Unknown)\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type describes the current condition\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\":{\"description\":\"HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of horizontal pod autoscaler objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscalerList\",\"version\":\"v2\"}]},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec\":{\"description\":\"HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler.\",\"properties\":{\"behavior\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior\"},\"maxReplicas\":{\"default\":0,\"description\":\"maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas.\",\"format\":\"int32\",\"type\":\"integer\"},\"metrics\":{\"description\":\"metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"minReplicas\":{\"description\":\"minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.\",\"format\":\"int32\",\"type\":\"integer\"},\"scaleTargetRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference\"}},\"required\":[\"scaleTargetRef\",\"maxReplicas\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus\":{\"description\":\"HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler.\",\"properties\":{\"conditions\":{\"description\":\"conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentMetrics\":{\"description\":\"currentMetrics is the last read state of the metrics used by this autoscaler.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"currentReplicas\":{\"description\":\"currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler.\",\"format\":\"int32\",\"type\":\"integer\"},\"desiredReplicas\":{\"default\":0,\"description\":\"desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler.\",\"format\":\"int32\",\"type\":\"integer\"},\"lastScaleTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"observedGeneration\":{\"description\":\"observedGeneration is the most recent generation observed by this autoscaler.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"desiredReplicas\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.MetricIdentifier\":{\"description\":\"MetricIdentifier defines the name and optionally selector for a metric\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name is the name of the given metric\",\"type\":\"string\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.MetricSpec\":{\"description\":\"MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once).\",\"properties\":{\"containerResource\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource\"},\"external\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource\"},\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource\"},\"pods\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource\"},\"resource\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource\"},\"type\":{\"default\":\"\",\"description\":\"type is the type of metric source. It should be one of \\\"ContainerResource\\\", \\\"External\\\", \\\"Object\\\", \\\"Pods\\\" or \\\"Resource\\\", each mapping to a matching field in the object.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.MetricStatus\":{\"description\":\"MetricStatus describes the last-read state of a single metric.\",\"properties\":{\"containerResource\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus\"},\"external\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus\"},\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus\"},\"pods\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus\"},\"resource\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus\"},\"type\":{\"default\":\"\",\"description\":\"type is the type of metric source. It will be one of \\\"ContainerResource\\\", \\\"External\\\", \\\"Object\\\", \\\"Pods\\\" or \\\"Resource\\\", each corresponds to a matching field in the object.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.MetricTarget\":{\"description\":\"MetricTarget defines the target value, average value, or average utilization of a specific metric\",\"properties\":{\"averageUtilization\":{\"description\":\"averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type\",\"format\":\"int32\",\"type\":\"integer\"},\"averageValue\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"type\":{\"default\":\"\",\"description\":\"type represents whether the metric type is Utilization, Value, or AverageValue\",\"type\":\"string\"},\"value\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"required\":[\"type\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.MetricValueStatus\":{\"description\":\"MetricValueStatus holds the current value for a metric\",\"properties\":{\"averageUtilization\":{\"description\":\"currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods.\",\"format\":\"int32\",\"type\":\"integer\"},\"averageValue\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"value\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ObjectMetricSource\":{\"description\":\"ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).\",\"properties\":{\"describedObject\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference\"},\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget\"}},\"required\":[\"describedObject\",\"target\",\"metric\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ObjectMetricStatus\":{\"description\":\"ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).\",\"properties\":{\"current\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus\"},\"describedObject\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference\"},\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"}},\"required\":[\"metric\",\"current\",\"describedObject\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.PodsMetricSource\":{\"description\":\"PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.\",\"properties\":{\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget\"}},\"required\":[\"metric\",\"target\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.PodsMetricStatus\":{\"description\":\"PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).\",\"properties\":{\"current\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus\"},\"metric\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier\"}},\"required\":[\"metric\",\"current\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ResourceMetricSource\":{\"description\":\"ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \\\"pods\\\" source. Only one \\\"target\\\" type should be set.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name is the name of the resource in question.\",\"type\":\"string\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget\"}},\"required\":[\"name\",\"target\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v2.ResourceMetricStatus\":{\"description\":\"ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \\\"pods\\\" source.\",\"properties\":{\"current\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of the resource in question.\",\"type\":\"string\"}},\"required\":[\"name\",\"current\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/autoscaling/v2/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getAutoscalingV2APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"]}},\"/apis/autoscaling/v2/horizontalpodautoscalers\":{\"get\":{\"description\":\"list or watch objects of kind HorizontalPodAutoscaler\",\"operationId\":\"listAutoscalingV2HorizontalPodAutoscalerForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers\":{\"delete\":{\"description\":\"delete collection of HorizontalPodAutoscaler\",\"operationId\":\"deleteAutoscalingV2CollectionNamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"get\":{\"description\":\"list or watch objects of kind HorizontalPodAutoscaler\",\"operationId\":\"listAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a HorizontalPodAutoscaler\",\"operationId\":\"createAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}}},\"/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}\":{\"delete\":{\"description\":\"delete a HorizontalPodAutoscaler\",\"operationId\":\"deleteAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"get\":{\"description\":\"read the specified HorizontalPodAutoscaler\",\"operationId\":\"readAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified HorizontalPodAutoscaler\",\"operationId\":\"patchAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"put\":{\"description\":\"replace the specified HorizontalPodAutoscaler\",\"operationId\":\"replaceAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}}},\"/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status\":{\"get\":{\"description\":\"read status of the specified HorizontalPodAutoscaler\",\"operationId\":\"readAutoscalingV2NamespacedHorizontalPodAutoscalerStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"parameters\":[{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified HorizontalPodAutoscaler\",\"operationId\":\"patchAutoscalingV2NamespacedHorizontalPodAutoscalerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"put\":{\"description\":\"replace status of the specified HorizontalPodAutoscaler\",\"operationId\":\"replaceAutoscalingV2NamespacedHorizontalPodAutoscalerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}}},\"/apis/autoscaling/v2/watch/horizontalpodautoscalers\":{\"get\":{\"description\":\"watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAutoscalingV2HorizontalPodAutoscalerListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers\":{\"get\":{\"description\":\"watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchAutoscalingV2NamespacedHorizontalPodAutoscalerList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchAutoscalingV2NamespacedHorizontalPodAutoscaler\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-bba44a609259208e5a6a.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"autoscaling_v2\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"HorizontalPodAutoscaler\",\"version\":\"v2\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the HorizontalPodAutoscaler\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiAutoscalingV2MetricTarget + averageutilization::Union{Absent,Int32,Nothing} = ABSENT + averagevalue::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + type_::String + value::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2MetricTarget}, value) = _decode(IoK8sApiAutoscalingV2MetricTarget, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2MetricTarget}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget"), _openapi_raw, "decoding IoK8sApiAutoscalingV2MetricTarget"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2MetricTarget") + _openapi_field_averageutilization = haskey(_openapi_object, "averageUtilization") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["averageUtilization"], _openapi_validate) : ABSENT + _openapi_field_averagevalue = haskey(_openapi_object, "averageValue") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["averageValue"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAutoscalingV2MetricTarget"), _openapi_validate) + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("averageUtilization","averageValue","type","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2MetricTarget(; averageutilization = _openapi_field_averageutilization, averagevalue = _openapi_field_averagevalue, type_ = _openapi_field_type_, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2MetricTarget) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.averageutilization isa Absent || (_openapi_output["averageUtilization"] = _encode(_openapi_value.averageutilization)) + _openapi_value.averagevalue isa Absent || (_openapi_output["averageValue"] = _encode(_openapi_value.averagevalue)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricTarget"), _openapi_output, "encoding IoK8sApiAutoscalingV2MetricTarget"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2MetricTarget) + _openapi_output = Pair{String,Any}[] + _openapi_value.averageutilization isa Absent || push!(_openapi_output, "averageUtilization" => _openapi_value.averageutilization) + _openapi_value.averagevalue isa Absent || push!(_openapi_output, "averageValue" => _openapi_value.averagevalue) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ContainerResourceMetricSource + container::String + name::String + target::IoK8sApiAutoscalingV2MetricTarget + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ContainerResourceMetricSource}, value) = _decode(IoK8sApiAutoscalingV2ContainerResourceMetricSource, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ContainerResourceMetricSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ContainerResourceMetricSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ContainerResourceMetricSource") + _openapi_field_container = _decode(String, _required(_openapi_object, "container", "IoK8sApiAutoscalingV2ContainerResourceMetricSource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2ContainerResourceMetricSource"), _openapi_validate) + _openapi_field_target = _decode(IoK8sApiAutoscalingV2MetricTarget, _required(_openapi_object, "target", "IoK8sApiAutoscalingV2ContainerResourceMetricSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("container","name","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ContainerResourceMetricSource(; container = _openapi_field_container, name = _openapi_field_name, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ContainerResourceMetricSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.container isa Absent || (_openapi_output["container"] = _encode(_openapi_value.container)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricSource"), _openapi_output, "encoding IoK8sApiAutoscalingV2ContainerResourceMetricSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ContainerResourceMetricSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.container isa Absent || push!(_openapi_output, "container" => _openapi_value.container) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2MetricValueStatus + averageutilization::Union{Absent,Int32,Nothing} = ABSENT + averagevalue::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + value::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2MetricValueStatus}, value) = _decode(IoK8sApiAutoscalingV2MetricValueStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2MetricValueStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2MetricValueStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2MetricValueStatus") + _openapi_field_averageutilization = haskey(_openapi_object, "averageUtilization") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["averageUtilization"], _openapi_validate) : ABSENT + _openapi_field_averagevalue = haskey(_openapi_object, "averageValue") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["averageValue"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("averageUtilization","averageValue","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2MetricValueStatus(; averageutilization = _openapi_field_averageutilization, averagevalue = _openapi_field_averagevalue, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2MetricValueStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.averageutilization isa Absent || (_openapi_output["averageUtilization"] = _encode(_openapi_value.averageutilization)) + _openapi_value.averagevalue isa Absent || (_openapi_output["averageValue"] = _encode(_openapi_value.averagevalue)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricValueStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2MetricValueStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2MetricValueStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.averageutilization isa Absent || push!(_openapi_output, "averageUtilization" => _openapi_value.averageutilization) + _openapi_value.averagevalue isa Absent || push!(_openapi_output, "averageValue" => _openapi_value.averagevalue) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ContainerResourceMetricStatus + container::String + current::IoK8sApiAutoscalingV2MetricValueStatus + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ContainerResourceMetricStatus}, value) = _decode(IoK8sApiAutoscalingV2ContainerResourceMetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ContainerResourceMetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ContainerResourceMetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ContainerResourceMetricStatus") + _openapi_field_container = _decode(String, _required(_openapi_object, "container", "IoK8sApiAutoscalingV2ContainerResourceMetricStatus"), _openapi_validate) + _openapi_field_current = _decode(IoK8sApiAutoscalingV2MetricValueStatus, _required(_openapi_object, "current", "IoK8sApiAutoscalingV2ContainerResourceMetricStatus"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2ContainerResourceMetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("container","current","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ContainerResourceMetricStatus(; container = _openapi_field_container, current = _openapi_field_current, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ContainerResourceMetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.container isa Absent || (_openapi_output["container"] = _encode(_openapi_value.container)) + _openapi_value.current isa Absent || (_openapi_output["current"] = _encode(_openapi_value.current)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2ContainerResourceMetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ContainerResourceMetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.container isa Absent || push!(_openapi_output, "container" => _openapi_value.container) + _openapi_value.current isa Absent || push!(_openapi_output, "current" => _openapi_value.current) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2CrossVersionObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2CrossVersionObjectReference}, value) = _decode(IoK8sApiAutoscalingV2CrossVersionObjectReference, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2CrossVersionObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference"), _openapi_raw, "decoding IoK8sApiAutoscalingV2CrossVersionObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2CrossVersionObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiAutoscalingV2CrossVersionObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2CrossVersionObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2CrossVersionObjectReference(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2CrossVersionObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.CrossVersionObjectReference"), _openapi_output, "encoding IoK8sApiAutoscalingV2CrossVersionObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2CrossVersionObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2MetricIdentifier + name::String + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2MetricIdentifier}, value) = _decode(IoK8sApiAutoscalingV2MetricIdentifier, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2MetricIdentifier}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier"), _openapi_raw, "decoding IoK8sApiAutoscalingV2MetricIdentifier"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2MetricIdentifier") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2MetricIdentifier"), _openapi_validate) + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","selector") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2MetricIdentifier(; name = _openapi_field_name, selector = _openapi_field_selector, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2MetricIdentifier) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier"), _openapi_output, "encoding IoK8sApiAutoscalingV2MetricIdentifier"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2MetricIdentifier) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ExternalMetricSource + metric::IoK8sApiAutoscalingV2MetricIdentifier + target::IoK8sApiAutoscalingV2MetricTarget + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ExternalMetricSource}, value) = _decode(IoK8sApiAutoscalingV2ExternalMetricSource, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ExternalMetricSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ExternalMetricSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ExternalMetricSource") + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2ExternalMetricSource"), _openapi_validate) + _openapi_field_target = _decode(IoK8sApiAutoscalingV2MetricTarget, _required(_openapi_object, "target", "IoK8sApiAutoscalingV2ExternalMetricSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metric","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ExternalMetricSource(; metric = _openapi_field_metric, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ExternalMetricSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricSource"), _openapi_output, "encoding IoK8sApiAutoscalingV2ExternalMetricSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ExternalMetricSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ExternalMetricStatus + current::IoK8sApiAutoscalingV2MetricValueStatus + metric::IoK8sApiAutoscalingV2MetricIdentifier + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ExternalMetricStatus}, value) = _decode(IoK8sApiAutoscalingV2ExternalMetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ExternalMetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ExternalMetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ExternalMetricStatus") + _openapi_field_current = _decode(IoK8sApiAutoscalingV2MetricValueStatus, _required(_openapi_object, "current", "IoK8sApiAutoscalingV2ExternalMetricStatus"), _openapi_validate) + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2ExternalMetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("current","metric") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ExternalMetricStatus(; current = _openapi_field_current, metric = _openapi_field_metric, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ExternalMetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.current isa Absent || (_openapi_output["current"] = _encode(_openapi_value.current)) + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ExternalMetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2ExternalMetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ExternalMetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.current isa Absent || push!(_openapi_output, "current" => _openapi_value.current) + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HPAScalingPolicy + periodseconds::Int32 + type_::String + value::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HPAScalingPolicy}, value) = _decode(IoK8sApiAutoscalingV2HPAScalingPolicy, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HPAScalingPolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HPAScalingPolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HPAScalingPolicy") + _openapi_field_periodseconds = _decode(Int32, _required(_openapi_object, "periodSeconds", "IoK8sApiAutoscalingV2HPAScalingPolicy"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAutoscalingV2HPAScalingPolicy"), _openapi_validate) + _openapi_field_value = _decode(Int32, _required(_openapi_object, "value", "IoK8sApiAutoscalingV2HPAScalingPolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("periodSeconds","type","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HPAScalingPolicy(; periodseconds = _openapi_field_periodseconds, type_ = _openapi_field_type_, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HPAScalingPolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.periodseconds isa Absent || (_openapi_output["periodSeconds"] = _encode(_openapi_value.periodseconds)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingPolicy"), _openapi_output, "encoding IoK8sApiAutoscalingV2HPAScalingPolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HPAScalingPolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.periodseconds isa Absent || push!(_openapi_output, "periodSeconds" => _openapi_value.periodseconds) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HPAScalingRules + policies::Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2HPAScalingPolicy}}} = ABSENT + selectpolicy::Union{Absent,Nothing,String} = ABSENT + stabilizationwindowseconds::Union{Absent,Int32,Nothing} = ABSENT + tolerance::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HPAScalingRules}, value) = _decode(IoK8sApiAutoscalingV2HPAScalingRules, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HPAScalingRules}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HPAScalingRules"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HPAScalingRules") + _openapi_field_policies = haskey(_openapi_object, "policies") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2HPAScalingPolicy}}}, _openapi_object["policies"], _openapi_validate) : ABSENT + _openapi_field_selectpolicy = haskey(_openapi_object, "selectPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selectPolicy"], _openapi_validate) : ABSENT + _openapi_field_stabilizationwindowseconds = haskey(_openapi_object, "stabilizationWindowSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["stabilizationWindowSeconds"], _openapi_validate) : ABSENT + _openapi_field_tolerance = haskey(_openapi_object, "tolerance") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["tolerance"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("policies","selectPolicy","stabilizationWindowSeconds","tolerance") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HPAScalingRules(; policies = _openapi_field_policies, selectpolicy = _openapi_field_selectpolicy, stabilizationwindowseconds = _openapi_field_stabilizationwindowseconds, tolerance = _openapi_field_tolerance, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HPAScalingRules) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.policies isa Absent || (_openapi_output["policies"] = _encode(_openapi_value.policies)) + _openapi_value.selectpolicy isa Absent || (_openapi_output["selectPolicy"] = _encode(_openapi_value.selectpolicy)) + _openapi_value.stabilizationwindowseconds isa Absent || (_openapi_output["stabilizationWindowSeconds"] = _encode(_openapi_value.stabilizationwindowseconds)) + _openapi_value.tolerance isa Absent || (_openapi_output["tolerance"] = _encode(_openapi_value.tolerance)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HPAScalingRules"), _openapi_output, "encoding IoK8sApiAutoscalingV2HPAScalingRules"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HPAScalingRules) + _openapi_output = Pair{String,Any}[] + _openapi_value.policies isa Absent || push!(_openapi_output, "policies" => _openapi_value.policies) + _openapi_value.selectpolicy isa Absent || push!(_openapi_output, "selectPolicy" => _openapi_value.selectpolicy) + _openapi_value.stabilizationwindowseconds isa Absent || push!(_openapi_output, "stabilizationWindowSeconds" => _openapi_value.stabilizationwindowseconds) + _openapi_value.tolerance isa Absent || push!(_openapi_output, "tolerance" => _openapi_value.tolerance) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior + scaledown::Union{Absent,IoK8sApiAutoscalingV2HPAScalingRules,Nothing} = ABSENT + scaleup::Union{Absent,IoK8sApiAutoscalingV2HPAScalingRules,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior") + _openapi_field_scaledown = haskey(_openapi_object, "scaleDown") ? _decode(Union{Absent,IoK8sApiAutoscalingV2HPAScalingRules,Nothing}, _openapi_object["scaleDown"], _openapi_validate) : ABSENT + _openapi_field_scaleup = haskey(_openapi_object, "scaleUp") ? _decode(Union{Absent,IoK8sApiAutoscalingV2HPAScalingRules,Nothing}, _openapi_object["scaleUp"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("scaleDown","scaleUp") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior(; scaledown = _openapi_field_scaledown, scaleup = _openapi_field_scaleup, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.scaledown isa Absent || (_openapi_output["scaleDown"] = _encode(_openapi_value.scaledown)) + _openapi_value.scaleup isa Absent || (_openapi_output["scaleUp"] = _encode(_openapi_value.scaleup)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior) + _openapi_output = Pair{String,Any}[] + _openapi_value.scaledown isa Absent || push!(_openapi_output, "scaleDown" => _openapi_value.scaledown) + _openapi_value.scaleup isa Absent || push!(_openapi_output, "scaleUp" => _openapi_value.scaleup) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ObjectMetricSource + describedobject::IoK8sApiAutoscalingV2CrossVersionObjectReference + metric::IoK8sApiAutoscalingV2MetricIdentifier + target::IoK8sApiAutoscalingV2MetricTarget + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ObjectMetricSource}, value) = _decode(IoK8sApiAutoscalingV2ObjectMetricSource, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ObjectMetricSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ObjectMetricSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ObjectMetricSource") + _openapi_field_describedobject = _decode(IoK8sApiAutoscalingV2CrossVersionObjectReference, _required(_openapi_object, "describedObject", "IoK8sApiAutoscalingV2ObjectMetricSource"), _openapi_validate) + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2ObjectMetricSource"), _openapi_validate) + _openapi_field_target = _decode(IoK8sApiAutoscalingV2MetricTarget, _required(_openapi_object, "target", "IoK8sApiAutoscalingV2ObjectMetricSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("describedObject","metric","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ObjectMetricSource(; describedobject = _openapi_field_describedobject, metric = _openapi_field_metric, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ObjectMetricSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.describedobject isa Absent || (_openapi_output["describedObject"] = _encode(_openapi_value.describedobject)) + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricSource"), _openapi_output, "encoding IoK8sApiAutoscalingV2ObjectMetricSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ObjectMetricSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.describedobject isa Absent || push!(_openapi_output, "describedObject" => _openapi_value.describedobject) + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2PodsMetricSource + metric::IoK8sApiAutoscalingV2MetricIdentifier + target::IoK8sApiAutoscalingV2MetricTarget + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2PodsMetricSource}, value) = _decode(IoK8sApiAutoscalingV2PodsMetricSource, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2PodsMetricSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource"), _openapi_raw, "decoding IoK8sApiAutoscalingV2PodsMetricSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2PodsMetricSource") + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2PodsMetricSource"), _openapi_validate) + _openapi_field_target = _decode(IoK8sApiAutoscalingV2MetricTarget, _required(_openapi_object, "target", "IoK8sApiAutoscalingV2PodsMetricSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metric","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2PodsMetricSource(; metric = _openapi_field_metric, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2PodsMetricSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricSource"), _openapi_output, "encoding IoK8sApiAutoscalingV2PodsMetricSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2PodsMetricSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ResourceMetricSource + name::String + target::IoK8sApiAutoscalingV2MetricTarget + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ResourceMetricSource}, value) = _decode(IoK8sApiAutoscalingV2ResourceMetricSource, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ResourceMetricSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ResourceMetricSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ResourceMetricSource") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2ResourceMetricSource"), _openapi_validate) + _openapi_field_target = _decode(IoK8sApiAutoscalingV2MetricTarget, _required(_openapi_object, "target", "IoK8sApiAutoscalingV2ResourceMetricSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ResourceMetricSource(; name = _openapi_field_name, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ResourceMetricSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricSource"), _openapi_output, "encoding IoK8sApiAutoscalingV2ResourceMetricSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ResourceMetricSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2MetricSpec + containerresource::Union{Absent,IoK8sApiAutoscalingV2ContainerResourceMetricSource,Nothing} = ABSENT + external::Union{Absent,IoK8sApiAutoscalingV2ExternalMetricSource,Nothing} = ABSENT + object::Union{Absent,IoK8sApiAutoscalingV2ObjectMetricSource,Nothing} = ABSENT + pods::Union{Absent,IoK8sApiAutoscalingV2PodsMetricSource,Nothing} = ABSENT + resource::Union{Absent,IoK8sApiAutoscalingV2ResourceMetricSource,Nothing} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2MetricSpec}, value) = _decode(IoK8sApiAutoscalingV2MetricSpec, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2MetricSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec"), _openapi_raw, "decoding IoK8sApiAutoscalingV2MetricSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2MetricSpec") + _openapi_field_containerresource = haskey(_openapi_object, "containerResource") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ContainerResourceMetricSource,Nothing}, _openapi_object["containerResource"], _openapi_validate) : ABSENT + _openapi_field_external = haskey(_openapi_object, "external") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ExternalMetricSource,Nothing}, _openapi_object["external"], _openapi_validate) : ABSENT + _openapi_field_object = haskey(_openapi_object, "object") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ObjectMetricSource,Nothing}, _openapi_object["object"], _openapi_validate) : ABSENT + _openapi_field_pods = haskey(_openapi_object, "pods") ? _decode(Union{Absent,IoK8sApiAutoscalingV2PodsMetricSource,Nothing}, _openapi_object["pods"], _openapi_validate) : ABSENT + _openapi_field_resource = haskey(_openapi_object, "resource") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ResourceMetricSource,Nothing}, _openapi_object["resource"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAutoscalingV2MetricSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerResource","external","object","pods","resource","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2MetricSpec(; containerresource = _openapi_field_containerresource, external = _openapi_field_external, object = _openapi_field_object, pods = _openapi_field_pods, resource = _openapi_field_resource, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2MetricSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerresource isa Absent || (_openapi_output["containerResource"] = _encode(_openapi_value.containerresource)) + _openapi_value.external isa Absent || (_openapi_output["external"] = _encode(_openapi_value.external)) + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.pods isa Absent || (_openapi_output["pods"] = _encode(_openapi_value.pods)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricSpec"), _openapi_output, "encoding IoK8sApiAutoscalingV2MetricSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2MetricSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerresource isa Absent || push!(_openapi_output, "containerResource" => _openapi_value.containerresource) + _openapi_value.external isa Absent || push!(_openapi_output, "external" => _openapi_value.external) + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.pods isa Absent || push!(_openapi_output, "pods" => _openapi_value.pods) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec + behavior::Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior,Nothing} = ABSENT + maxreplicas::Int32 + metrics::Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2MetricSpec}}} = ABSENT + minreplicas::Union{Absent,Int32,Nothing} = ABSENT + scaletargetref::IoK8sApiAutoscalingV2CrossVersionObjectReference + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec") + _openapi_field_behavior = haskey(_openapi_object, "behavior") ? _decode(Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerBehavior,Nothing}, _openapi_object["behavior"], _openapi_validate) : ABSENT + _openapi_field_maxreplicas = _decode(Int32, _required(_openapi_object, "maxReplicas", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec"), _openapi_validate) + _openapi_field_metrics = haskey(_openapi_object, "metrics") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2MetricSpec}}}, _openapi_object["metrics"], _openapi_validate) : ABSENT + _openapi_field_minreplicas = haskey(_openapi_object, "minReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReplicas"], _openapi_validate) : ABSENT + _openapi_field_scaletargetref = _decode(IoK8sApiAutoscalingV2CrossVersionObjectReference, _required(_openapi_object, "scaleTargetRef", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("behavior","maxReplicas","metrics","minReplicas","scaleTargetRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec(; behavior = _openapi_field_behavior, maxreplicas = _openapi_field_maxreplicas, metrics = _openapi_field_metrics, minreplicas = _openapi_field_minreplicas, scaletargetref = _openapi_field_scaletargetref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.behavior isa Absent || (_openapi_output["behavior"] = _encode(_openapi_value.behavior)) + _openapi_value.maxreplicas isa Absent || (_openapi_output["maxReplicas"] = _encode(_openapi_value.maxreplicas)) + _openapi_value.metrics isa Absent || (_openapi_output["metrics"] = _encode(_openapi_value.metrics)) + _openapi_value.minreplicas isa Absent || (_openapi_output["minReplicas"] = _encode(_openapi_value.minreplicas)) + _openapi_value.scaletargetref isa Absent || (_openapi_output["scaleTargetRef"] = _encode(_openapi_value.scaletargetref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.behavior isa Absent || push!(_openapi_output, "behavior" => _openapi_value.behavior) + _openapi_value.maxreplicas isa Absent || push!(_openapi_output, "maxReplicas" => _openapi_value.maxreplicas) + _openapi_value.metrics isa Absent || push!(_openapi_output, "metrics" => _openapi_value.metrics) + _openapi_value.minreplicas isa Absent || push!(_openapi_output, "minReplicas" => _openapi_value.minreplicas) + _openapi_value.scaletargetref isa Absent || push!(_openapi_output, "scaleTargetRef" => _openapi_value.scaletargetref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ObjectMetricStatus + current::IoK8sApiAutoscalingV2MetricValueStatus + describedobject::IoK8sApiAutoscalingV2CrossVersionObjectReference + metric::IoK8sApiAutoscalingV2MetricIdentifier + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ObjectMetricStatus}, value) = _decode(IoK8sApiAutoscalingV2ObjectMetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ObjectMetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ObjectMetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ObjectMetricStatus") + _openapi_field_current = _decode(IoK8sApiAutoscalingV2MetricValueStatus, _required(_openapi_object, "current", "IoK8sApiAutoscalingV2ObjectMetricStatus"), _openapi_validate) + _openapi_field_describedobject = _decode(IoK8sApiAutoscalingV2CrossVersionObjectReference, _required(_openapi_object, "describedObject", "IoK8sApiAutoscalingV2ObjectMetricStatus"), _openapi_validate) + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2ObjectMetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("current","describedObject","metric") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ObjectMetricStatus(; current = _openapi_field_current, describedobject = _openapi_field_describedobject, metric = _openapi_field_metric, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ObjectMetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.current isa Absent || (_openapi_output["current"] = _encode(_openapi_value.current)) + _openapi_value.describedobject isa Absent || (_openapi_output["describedObject"] = _encode(_openapi_value.describedobject)) + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ObjectMetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2ObjectMetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ObjectMetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.current isa Absent || push!(_openapi_output, "current" => _openapi_value.current) + _openapi_value.describedobject isa Absent || push!(_openapi_output, "describedObject" => _openapi_value.describedobject) + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2PodsMetricStatus + current::IoK8sApiAutoscalingV2MetricValueStatus + metric::IoK8sApiAutoscalingV2MetricIdentifier + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2PodsMetricStatus}, value) = _decode(IoK8sApiAutoscalingV2PodsMetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2PodsMetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2PodsMetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2PodsMetricStatus") + _openapi_field_current = _decode(IoK8sApiAutoscalingV2MetricValueStatus, _required(_openapi_object, "current", "IoK8sApiAutoscalingV2PodsMetricStatus"), _openapi_validate) + _openapi_field_metric = _decode(IoK8sApiAutoscalingV2MetricIdentifier, _required(_openapi_object, "metric", "IoK8sApiAutoscalingV2PodsMetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("current","metric") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2PodsMetricStatus(; current = _openapi_field_current, metric = _openapi_field_metric, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2PodsMetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.current isa Absent || (_openapi_output["current"] = _encode(_openapi_value.current)) + _openapi_value.metric isa Absent || (_openapi_output["metric"] = _encode(_openapi_value.metric)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.PodsMetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2PodsMetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2PodsMetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.current isa Absent || push!(_openapi_output, "current" => _openapi_value.current) + _openapi_value.metric isa Absent || push!(_openapi_output, "metric" => _openapi_value.metric) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2ResourceMetricStatus + current::IoK8sApiAutoscalingV2MetricValueStatus + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2ResourceMetricStatus}, value) = _decode(IoK8sApiAutoscalingV2ResourceMetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2ResourceMetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2ResourceMetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2ResourceMetricStatus") + _openapi_field_current = _decode(IoK8sApiAutoscalingV2MetricValueStatus, _required(_openapi_object, "current", "IoK8sApiAutoscalingV2ResourceMetricStatus"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiAutoscalingV2ResourceMetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("current","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2ResourceMetricStatus(; current = _openapi_field_current, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2ResourceMetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.current isa Absent || (_openapi_output["current"] = _encode(_openapi_value.current)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.ResourceMetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2ResourceMetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2ResourceMetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.current isa Absent || push!(_openapi_output, "current" => _openapi_value.current) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2MetricStatus + containerresource::Union{Absent,IoK8sApiAutoscalingV2ContainerResourceMetricStatus,Nothing} = ABSENT + external::Union{Absent,IoK8sApiAutoscalingV2ExternalMetricStatus,Nothing} = ABSENT + object::Union{Absent,IoK8sApiAutoscalingV2ObjectMetricStatus,Nothing} = ABSENT + pods::Union{Absent,IoK8sApiAutoscalingV2PodsMetricStatus,Nothing} = ABSENT + resource::Union{Absent,IoK8sApiAutoscalingV2ResourceMetricStatus,Nothing} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2MetricStatus}, value) = _decode(IoK8sApiAutoscalingV2MetricStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2MetricStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2MetricStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2MetricStatus") + _openapi_field_containerresource = haskey(_openapi_object, "containerResource") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ContainerResourceMetricStatus,Nothing}, _openapi_object["containerResource"], _openapi_validate) : ABSENT + _openapi_field_external = haskey(_openapi_object, "external") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ExternalMetricStatus,Nothing}, _openapi_object["external"], _openapi_validate) : ABSENT + _openapi_field_object = haskey(_openapi_object, "object") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ObjectMetricStatus,Nothing}, _openapi_object["object"], _openapi_validate) : ABSENT + _openapi_field_pods = haskey(_openapi_object, "pods") ? _decode(Union{Absent,IoK8sApiAutoscalingV2PodsMetricStatus,Nothing}, _openapi_object["pods"], _openapi_validate) : ABSENT + _openapi_field_resource = haskey(_openapi_object, "resource") ? _decode(Union{Absent,IoK8sApiAutoscalingV2ResourceMetricStatus,Nothing}, _openapi_object["resource"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiAutoscalingV2MetricStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerResource","external","object","pods","resource","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2MetricStatus(; containerresource = _openapi_field_containerresource, external = _openapi_field_external, object = _openapi_field_object, pods = _openapi_field_pods, resource = _openapi_field_resource, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2MetricStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerresource isa Absent || (_openapi_output["containerResource"] = _encode(_openapi_value.containerresource)) + _openapi_value.external isa Absent || (_openapi_output["external"] = _encode(_openapi_value.external)) + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.pods isa Absent || (_openapi_output["pods"] = _encode(_openapi_value.pods)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.MetricStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2MetricStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2MetricStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerresource isa Absent || push!(_openapi_output, "containerResource" => _openapi_value.containerresource) + _openapi_value.external isa Absent || push!(_openapi_output, "external" => _openapi_value.external) + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.pods isa Absent || push!(_openapi_output, "pods" => _openapi_value.pods) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition}}} = ABSENT + currentmetrics::Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2MetricStatus}}} = ABSENT + currentreplicas::Union{Absent,Int32,Nothing} = ABSENT + desiredreplicas::Int32 + lastscaletime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2HorizontalPodAutoscalerCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currentmetrics = haskey(_openapi_object, "currentMetrics") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiAutoscalingV2MetricStatus}}}, _openapi_object["currentMetrics"], _openapi_validate) : ABSENT + _openapi_field_currentreplicas = haskey(_openapi_object, "currentReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["currentReplicas"], _openapi_validate) : ABSENT + _openapi_field_desiredreplicas = _decode(Int32, _required(_openapi_object, "desiredReplicas", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus"), _openapi_validate) + _openapi_field_lastscaletime = haskey(_openapi_object, "lastScaleTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastScaleTime"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions","currentMetrics","currentReplicas","desiredReplicas","lastScaleTime","observedGeneration") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus(; conditions = _openapi_field_conditions, currentmetrics = _openapi_field_currentmetrics, currentreplicas = _openapi_field_currentreplicas, desiredreplicas = _openapi_field_desiredreplicas, lastscaletime = _openapi_field_lastscaletime, observedgeneration = _openapi_field_observedgeneration, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currentmetrics isa Absent || (_openapi_output["currentMetrics"] = _encode(_openapi_value.currentmetrics)) + _openapi_value.currentreplicas isa Absent || (_openapi_output["currentReplicas"] = _encode(_openapi_value.currentreplicas)) + _openapi_value.desiredreplicas isa Absent || (_openapi_output["desiredReplicas"] = _encode(_openapi_value.desiredreplicas)) + _openapi_value.lastscaletime isa Absent || (_openapi_output["lastScaleTime"] = _encode(_openapi_value.lastscaletime)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currentmetrics isa Absent || push!(_openapi_output, "currentMetrics" => _openapi_value.currentmetrics) + _openapi_value.currentreplicas isa Absent || push!(_openapi_output, "currentReplicas" => _openapi_value.currentreplicas) + _openapi_value.desiredreplicas isa Absent || push!(_openapi_output, "desiredReplicas" => _openapi_value.desiredreplicas) + _openapi_value.lastscaletime isa Absent || push!(_openapi_output, "lastScaleTime" => _openapi_value.lastscaletime) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscaler + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscaler}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscaler, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscaler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscaler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscaler") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAutoscalingV2HorizontalPodAutoscalerStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscaler(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscaler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscaler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscaler) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV2HorizontalPodAutoscalerList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiAutoscalingV2HorizontalPodAutoscaler}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerList}, value) = _decode(IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, value, true) +function _decode(::Type{IoK8sApiAutoscalingV2HorizontalPodAutoscalerList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList"), _openapi_raw, "decoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV2HorizontalPodAutoscalerList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiAutoscalingV2HorizontalPodAutoscaler}}, _required(_openapi_object, "items", "IoK8sApiAutoscalingV2HorizontalPodAutoscalerList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV2HorizontalPodAutoscalerList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList"), _openapi_output, "encoding IoK8sApiAutoscalingV2HorizontalPodAutoscalerList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV2HorizontalPodAutoscalerList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getautoscalingv2apiresources = ( + id = "getAutoscalingV2APIResources", + method = "GET", + path = "/apis/autoscaling/v2/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getautoscalingv2apiresources(...)\n\nget available resources\n\n`GET /apis/autoscaling/v2/`" +function getautoscalingv2apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getautoscalingv2apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listautoscalingv2horizontalpodautoscalerforallnamespaces = ( + id = "listAutoscalingV2HorizontalPodAutoscalerForAllNamespaces", + method = "GET", + path = "/apis/autoscaling/v2/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listautoscalingv2horizontalpodautoscalerforallnamespaces(...)\n\nlist or watch objects of kind HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v2/horizontalpodautoscalers`" +function listautoscalingv2horizontalpodautoscalerforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listautoscalingv2horizontalpodautoscalerforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteautoscalingv2collectionnamespacedhorizontalpodautoscaler = ( + id = "deleteAutoscalingV2CollectionNamespacedHorizontalPodAutoscaler", + method = "DELETE", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteautoscalingv2collectionnamespacedhorizontalpodautoscaler(...)\n\ndelete collection of HorizontalPodAutoscaler\n\n`DELETE /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers`" +function deleteautoscalingv2collectionnamespacedhorizontalpodautoscaler(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteautoscalingv2collectionnamespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "listAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listautoscalingv2namespacedhorizontalpodautoscaler(...)\n\nlist or watch objects of kind HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers`" +function listautoscalingv2namespacedhorizontalpodautoscaler(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "createAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "POST", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createautoscalingv2namespacedhorizontalpodautoscaler(...)\n\ncreate a HorizontalPodAutoscaler\n\n`POST /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers`" +function createautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, body::IoK8sApiAutoscalingV2HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "deleteAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "DELETE", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteautoscalingv2namespacedhorizontalpodautoscaler(...)\n\ndelete a HorizontalPodAutoscaler\n\n`DELETE /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function deleteautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "readAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readautoscalingv2namespacedhorizontalpodautoscaler(...)\n\nread the specified HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function readautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "patchAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "PATCH", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchautoscalingv2namespacedhorizontalpodautoscaler(...)\n\npartially update the specified HorizontalPodAutoscaler\n\n`PATCH /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function patchautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "replaceAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "PUT", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceautoscalingv2namespacedhorizontalpodautoscaler(...)\n\nreplace the specified HorizontalPodAutoscaler\n\n`PUT /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function replaceautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, name::String, body::IoK8sApiAutoscalingV2HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readautoscalingv2namespacedhorizontalpodautoscalerstatus = ( + id = "readAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + method = "GET", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readautoscalingv2namespacedhorizontalpodautoscalerstatus(...)\n\nread status of the specified HorizontalPodAutoscaler\n\n`GET /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function readautoscalingv2namespacedhorizontalpodautoscalerstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readautoscalingv2namespacedhorizontalpodautoscalerstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchautoscalingv2namespacedhorizontalpodautoscalerstatus = ( + id = "patchAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + method = "PATCH", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchautoscalingv2namespacedhorizontalpodautoscalerstatus(...)\n\npartially update status of the specified HorizontalPodAutoscaler\n\n`PATCH /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function patchautoscalingv2namespacedhorizontalpodautoscalerstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchautoscalingv2namespacedhorizontalpodautoscalerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceautoscalingv2namespacedhorizontalpodautoscalerstatus = ( + id = "replaceAutoscalingV2NamespacedHorizontalPodAutoscalerStatus", + method = "PUT", + path = "/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV2HorizontalPodAutoscaler, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceautoscalingv2namespacedhorizontalpodautoscalerstatus(...)\n\nreplace status of the specified HorizontalPodAutoscaler\n\n`PUT /apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status`" +function replaceautoscalingv2namespacedhorizontalpodautoscalerstatus(namespace::String, name::String, body::IoK8sApiAutoscalingV2HorizontalPodAutoscaler; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceautoscalingv2namespacedhorizontalpodautoscalerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv2horizontalpodautoscalerlistforallnamespaces = ( + id = "watchAutoscalingV2HorizontalPodAutoscalerListForAllNamespaces", + method = "GET", + path = "/apis/autoscaling/v2/watch/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv2horizontalpodautoscalerlistforallnamespaces(...)\n\nwatch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/autoscaling/v2/watch/horizontalpodautoscalers`" +function watchautoscalingv2horizontalpodautoscalerlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv2horizontalpodautoscalerlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv2namespacedhorizontalpodautoscalerlist = ( + id = "watchAutoscalingV2NamespacedHorizontalPodAutoscalerList", + method = "GET", + path = "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv2namespacedhorizontalpodautoscalerlist(...)\n\nwatch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers`" +function watchautoscalingv2namespacedhorizontalpodautoscalerlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv2namespacedhorizontalpodautoscalerlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchautoscalingv2namespacedhorizontalpodautoscaler = ( + id = "watchAutoscalingV2NamespacedHorizontalPodAutoscaler", + method = "GET", + path = "/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-bba44a609259208e5a6a.json", pointer = "/paths/~1apis~1autoscaling~1v2~1watch~1namespaces~1{namespace}~1horizontalpodautoscalers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchautoscalingv2namespacedhorizontalpodautoscaler(...)\n\nwatch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}`" +function watchautoscalingv2namespacedhorizontalpodautoscaler(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchautoscalingv2namespacedhorizontalpodautoscaler, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sAutoscalingV2 diff --git a/src/ApiImpl/generated/K8sBatchV1.jl b/src/ApiImpl/generated/K8sBatchV1.jl new file mode 100644 index 00000000..78979134 --- /dev/null +++ b/src/ApiImpl/generated/K8sBatchV1.jl @@ -0,0 +1,8583 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sBatchV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", retrieval = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.batch.v1.CronJob\":{\"description\":\"CronJob represents the configuration of a single cron job.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}]},\"io.k8s.api.batch.v1.CronJobList\":{\"description\":\"CronJobList is a collection of cron jobs.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of CronJobs.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"batch\",\"kind\":\"CronJobList\",\"version\":\"v1\"}]},\"io.k8s.api.batch.v1.CronJobSpec\":{\"description\":\"CronJobSpec describes how the job execution will look like and when it will actually run.\",\"properties\":{\"concurrencyPolicy\":{\"description\":\"Specifies how to treat concurrent executions of a Job. Valid values are:\\n\\n- \\\"Allow\\\" (default): allows CronJobs to run concurrently; - \\\"Forbid\\\": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - \\\"Replace\\\": cancels currently running job and replaces it with a new one\",\"type\":\"string\"},\"failedJobsHistoryLimit\":{\"description\":\"The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"jobTemplate\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec\"},\"schedule\":{\"default\":\"\",\"description\":\"The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.\",\"type\":\"string\"},\"startingDeadlineSeconds\":{\"description\":\"Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones.\",\"format\":\"int64\",\"type\":\"integer\"},\"successfulJobsHistoryLimit\":{\"description\":\"The number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3.\",\"format\":\"int32\",\"type\":\"integer\"},\"suspend\":{\"description\":\"This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false.\",\"type\":\"boolean\"},\"timeZone\":{\"description\":\"The time zone name for the given schedule, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. If not specified, this will default to the time zone of the kube-controller-manager process. The set of valid time zone names and the time zone offset is loaded from the system-wide time zone database by the API server during CronJob validation and the controller manager during execution. If no system-wide time zone database can be found a bundled version of the database is used instead. If the time zone name becomes invalid during the lifetime of a CronJob or due to a change in host configuration, the controller will stop creating new new Jobs and will create a system event with the reason UnknownTimeZone. More information can be found in https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#time-zones\",\"type\":\"string\"}},\"required\":[\"schedule\",\"jobTemplate\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.CronJobStatus\":{\"description\":\"CronJobStatus represents the current state of a cron job.\",\"properties\":{\"active\":{\"description\":\"A list of pointers to currently running jobs.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"lastScheduleTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastSuccessfulTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.api.batch.v1.Job\":{\"description\":\"Job represents the configuration of a single job.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}]},\"io.k8s.api.batch.v1.JobCondition\":{\"description\":\"JobCondition describes current state of a job.\",\"properties\":{\"lastProbeTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Human readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"(brief) reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of job condition, Complete or Failed.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.JobList\":{\"description\":\"JobList is a collection of jobs.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of Jobs.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"batch\",\"kind\":\"JobList\",\"version\":\"v1\"}]},\"io.k8s.api.batch.v1.JobSpec\":{\"description\":\"JobSpec describes how the job execution will look like.\",\"properties\":{\"activeDeadlineSeconds\":{\"description\":\"Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again.\",\"format\":\"int64\",\"type\":\"integer\"},\"backoffLimit\":{\"description\":\"Specifies the number of retries before marking this job failed. Defaults to 6, unless backoffLimitPerIndex (only Indexed Job) is specified. When backoffLimitPerIndex is specified, backoffLimit defaults to 2147483647.\",\"format\":\"int32\",\"type\":\"integer\"},\"backoffLimitPerIndex\":{\"description\":\"Specifies the limit for the number of retries within an index before marking this index as failed. When enabled the number of failures per index is kept in the pod's batch.kubernetes.io/job-index-failure-count annotation. It can only be set when Job's completionMode=Indexed, and the Pod's restart policy is Never. The field is immutable.\",\"format\":\"int32\",\"type\":\"integer\"},\"completionMode\":{\"description\":\"completionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.\\n\\n`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other.\\n\\n`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `\$(job-name)-\$(index)-\$(random-string)`, the Pod hostname takes the form `\$(job-name)-\$(index)`.\\n\\nMore completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, which is possible during upgrades due to version skew, the controller skips updates for the Job.\",\"type\":\"string\"},\"completions\":{\"description\":\"Specifies the desired number of successfully finished pods the job should be run with. Setting to null means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/\",\"format\":\"int32\",\"type\":\"integer\"},\"managedBy\":{\"description\":\"ManagedBy field indicates the controller that manages a Job. The k8s Job controller reconciles jobs which don't have this field at all or the field value is the reserved string `kubernetes.io/job-controller`, but skips reconciling Jobs with a custom value for this field. The value must be a valid domain-prefixed path (e.g. acme.io/foo) - all characters before the first \\\"/\\\" must be a valid subdomain as defined by RFC 1123. All characters trailing the first \\\"/\\\" must be valid HTTP Path characters as defined by RFC 3986. The value cannot exceed 63 characters. This field is immutable.\",\"type\":\"string\"},\"manualSelector\":{\"description\":\"manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector\",\"type\":\"boolean\"},\"maxFailedIndexes\":{\"description\":\"Specifies the maximal number of failed indexes before marking the Job as failed, when backoffLimitPerIndex is set. Once the number of failed indexes exceeds this number the entire Job is marked as Failed and its execution is terminated. When left as null the job continues execution of all of its indexes and is marked with the `Complete` Job condition. It can only be specified when backoffLimitPerIndex is set. It can be null or up to completions. It is required and must be less than or equal to 10^4 when is completions greater than 10^5.\",\"format\":\"int32\",\"type\":\"integer\"},\"parallelism\":{\"description\":\"Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/\",\"format\":\"int32\",\"type\":\"integer\"},\"podFailurePolicy\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy\"},\"podReplacementPolicy\":{\"description\":\"podReplacementPolicy specifies when to create replacement Pods. Possible values are: - TerminatingOrFailed means that we recreate pods\\n when they are terminating (has a metadata.deletionTimestamp) or failed.\\n- Failed means to wait until a previously created Pod is fully terminated (has phase\\n Failed or Succeeded) before creating a replacement Pod.\\n\\nWhen using podFailurePolicy, Failed is the the only allowed value. TerminatingOrFailed and Failed are allowed values when podFailurePolicy is not in use.\",\"type\":\"string\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"successPolicy\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.SuccessPolicy\"},\"suspend\":{\"description\":\"suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false.\",\"type\":\"boolean\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"},\"ttlSecondsAfterFinished\":{\"description\":\"ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"template\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.JobStatus\":{\"description\":\"JobStatus represents the current state of a Job.\",\"properties\":{\"active\":{\"description\":\"The number of pending and running pods which are not terminating (without a deletionTimestamp). The value is zero for finished jobs.\",\"format\":\"int32\",\"type\":\"integer\"},\"completedIndexes\":{\"description\":\"completedIndexes holds the completed indexes when .spec.completionMode = \\\"Indexed\\\" in a text format. The indexes are represented as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \\\"1,3-5,7\\\".\",\"type\":\"string\"},\"completionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"conditions\":{\"description\":\"The latest available observations of an object's current state. When a Job fails, one of the conditions will have type \\\"Failed\\\" and status true. When a Job is suspended, one of the conditions will have type \\\"Suspended\\\" and status true; when the Job is resumed, the status of this condition will become false. When a Job is completed, one of the conditions will have type \\\"Complete\\\" and status true.\\n\\nA job is considered finished when it is in a terminal condition, either \\\"Complete\\\" or \\\"Failed\\\". A Job cannot have both the \\\"Complete\\\" and \\\"Failed\\\" conditions. Additionally, it cannot be in the \\\"Complete\\\" and \\\"FailureTarget\\\" conditions. The \\\"Complete\\\", \\\"Failed\\\" and \\\"FailureTarget\\\" conditions cannot be disabled.\\n\\nMore info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"failed\":{\"description\":\"The number of pods which reached phase Failed. The value increases monotonically.\",\"format\":\"int32\",\"type\":\"integer\"},\"failedIndexes\":{\"description\":\"FailedIndexes holds the failed indexes when spec.backoffLimitPerIndex is set. The indexes are represented in the text format analogous as for the `completedIndexes` field, ie. they are kept as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the failed indexes are 1, 3, 4, 5 and 7, they are represented as \\\"1,3-5,7\\\". The set of failed indexes cannot overlap with the set of completed indexes.\",\"type\":\"string\"},\"ready\":{\"description\":\"The number of active pods which have a Ready condition and are not terminating (without a deletionTimestamp).\",\"format\":\"int32\",\"type\":\"integer\"},\"startTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"succeeded\":{\"description\":\"The number of pods which reached phase Succeeded. The value increases monotonically for a given spec. However, it may decrease in reaction to scale down of elastic indexed jobs.\",\"format\":\"int32\",\"type\":\"integer\"},\"terminating\":{\"description\":\"The number of pods which are terminating (in phase Pending or Running and have a deletionTimestamp).\\n\\nThis field is beta-level. The job controller populates the field when the feature gate JobPodReplacementPolicy is enabled (enabled by default).\",\"format\":\"int32\",\"type\":\"integer\"},\"uncountedTerminatedPods\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods\"}},\"type\":\"object\"},\"io.k8s.api.batch.v1.JobTemplateSpec\":{\"description\":\"JobTemplateSpec describes the data a Job should have when created from a template\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobSpec\"}},\"type\":\"object\"},\"io.k8s.api.batch.v1.PodFailurePolicy\":{\"description\":\"PodFailurePolicy describes how failed pods influence the backoffLimit.\",\"properties\":{\"rules\":{\"description\":\"A list of pod failure policy rules. The rules are evaluated in order. Once a rule matches a Pod failure, the remaining of the rules are ignored. When no rule matches the Pod failure, the default handling applies - the counter of pod failures is incremented and it is checked against the backoffLimit. At most 20 elements are allowed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"rules\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement\":{\"description\":\"PodFailurePolicyOnExitCodesRequirement describes the requirement for handling a failed pod based on its container exit codes. In particular, it lookups the .state.terminated.exitCode for each app container and init container status, represented by the .status.containerStatuses and .status.initContainerStatuses fields in the Pod status, respectively. Containers completed with success (exit code 0) are excluded from the requirement check.\",\"properties\":{\"containerName\":{\"description\":\"Restricts the check for exit codes to the container with the specified name. When null, the rule applies to all containers. When specified, it should match one the container or initContainer names in the pod template.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"Represents the relationship between the container exit code(s) and the specified values. Containers completed with success (exit code 0) are excluded from the requirement check. Possible values are:\\n\\n- In: the requirement is satisfied if at least one container exit code\\n (might be multiple if there are multiple containers not restricted\\n by the 'containerName' field) is in the set of specified values.\\n- NotIn: the requirement is satisfied if at least one container exit code\\n (might be multiple if there are multiple containers not restricted\\n by the 'containerName' field) is not in the set of specified values.\\nAdditional values are considered to be added in the future. Clients should react to an unknown operator by assuming the requirement is not satisfied.\",\"type\":\"string\"},\"values\":{\"description\":\"Specifies the set of values. Each returned container exit code (might be multiple in case of multiple containers) is checked against this set of values with respect to the operator. The list of values must be ordered and must not contain duplicates. Value '0' cannot be used for the In operator. At least one element is required. At most 255 elements are allowed.\",\"items\":{\"default\":0,\"format\":\"int32\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"required\":[\"operator\",\"values\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern\":{\"description\":\"PodFailurePolicyOnPodConditionsPattern describes a pattern for matching an actual pod condition type.\",\"properties\":{\"status\":{\"default\":\"\",\"description\":\"Specifies the required Pod condition status. To match a pod condition it is required that the specified status equals the pod condition status. Defaults to True.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Specifies the required Pod condition type. To match a pod condition it is required that specified type equals the pod condition type.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.PodFailurePolicyRule\":{\"description\":\"PodFailurePolicyRule describes how a pod failure is handled when the requirements are met. One of onExitCodes and onPodConditions, but not both, can be used in each rule.\",\"properties\":{\"action\":{\"default\":\"\",\"description\":\"Specifies the action taken on a pod failure when the requirements are satisfied. Possible values are:\\n\\n- FailJob: indicates that the pod's job is marked as Failed and all\\n running pods are terminated.\\n- FailIndex: indicates that the pod's index is marked as Failed and will\\n not be restarted.\\n- Ignore: indicates that the counter towards the .backoffLimit is not\\n incremented and a replacement pod is created.\\n- Count: indicates that the pod is handled in the default way - the\\n counter towards the .backoffLimit is incremented.\\nAdditional values are considered to be added in the future. Clients should react to an unknown action by skipping the rule.\",\"type\":\"string\"},\"onExitCodes\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement\"},\"onPodConditions\":{\"description\":\"Represents the requirement on the pod conditions. The requirement is represented as a list of pod condition patterns. The requirement is satisfied if at least one pattern matches an actual pod condition. At most 20 elements are allowed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"action\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.SuccessPolicy\":{\"description\":\"SuccessPolicy describes when a Job can be declared as succeeded based on the success of some indexes.\",\"properties\":{\"rules\":{\"description\":\"rules represents the list of alternative rules for the declaring the Jobs as successful before `.status.succeeded >= .spec.completions`. Once any of the rules are met, the \\\"SuccessCriteriaMet\\\" condition is added, and the lingering pods are removed. The terminal state for such a Job has the \\\"Complete\\\" condition. Additionally, these rules are evaluated in order; Once the Job meets one of the rules, other rules are ignored. At most 20 elements are allowed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"rules\"],\"type\":\"object\"},\"io.k8s.api.batch.v1.SuccessPolicyRule\":{\"description\":\"SuccessPolicyRule describes rule for declaring a Job as succeeded. Each rule must have at least one of the \\\"succeededIndexes\\\" or \\\"succeededCount\\\" specified.\",\"properties\":{\"succeededCount\":{\"description\":\"succeededCount specifies the minimal required size of the actual set of the succeeded indexes for the Job. When succeededCount is used along with succeededIndexes, the check is constrained only to the set of indexes specified by succeededIndexes. For example, given that succeededIndexes is \\\"1-4\\\", succeededCount is \\\"3\\\", and completed indexes are \\\"1\\\", \\\"3\\\", and \\\"5\\\", the Job isn't declared as succeeded because only \\\"1\\\" and \\\"3\\\" indexes are considered in that rules. When this field is null, this doesn't default to any value and is never evaluated at any time. When specified it needs to be a positive integer.\",\"format\":\"int32\",\"type\":\"integer\"},\"succeededIndexes\":{\"description\":\"succeededIndexes specifies the set of indexes which need to be contained in the actual set of the succeeded indexes for the Job. The list of indexes must be within 0 to \\\".spec.completions-1\\\" and must not contain duplicates. At least one element is required. The indexes are represented as intervals separated by commas. The intervals can be a decimal integer or a pair of decimal integers separated by a hyphen. The number are listed in represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \\\"1,3-5,7\\\". When this field is null, this field doesn't default to any value and is never evaluated at any time.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.batch.v1.UncountedTerminatedPods\":{\"description\":\"UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters.\",\"properties\":{\"failed\":{\"description\":\"failed holds UIDs of failed Pods.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true},\"succeeded\":{\"description\":\"succeeded holds UIDs of succeeded Pods.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in AWS.\\n\\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty).\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Affinity\":{\"description\":\"Affinity is a group of affinity scheduling rules.\",\"properties\":{\"nodeAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeAffinity\"},\"podAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodAffinity\"},\"podAntiAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.AppArmorProfile\":{\"description\":\"AppArmorProfile defines a pod or container's AppArmor settings.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \\\"Localhost\\\".\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of AppArmor profile will be applied. Valid options are:\\n Localhost - a profile pre-loaded on the node.\\n RuntimeDefault - the container runtime's default profile.\\n Unconfined - no AppArmor enforcement.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.AzureDiskVolumeSource\":{\"description\":\"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.\",\"properties\":{\"cachingMode\":{\"default\":\"ReadWrite\",\"description\":\"cachingMode is the Host Caching mode: None, Read Only, Read Write.\",\"type\":\"string\"},\"diskName\":{\"default\":\"\",\"description\":\"diskName is the Name of the data disk in the blob storage\",\"type\":\"string\"},\"diskURI\":{\"default\":\"\",\"description\":\"diskURI is the URI of data disk in the blob storage\",\"type\":\"string\"},\"fsType\":{\"default\":\"ext4\",\"description\":\"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"kind\":{\"default\":\"Shared\",\"description\":\"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared\",\"type\":\"string\"},\"readOnly\":{\"default\":false,\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"}},\"required\":[\"diskName\",\"diskURI\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureFileVolumeSource\":{\"description\":\"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.\",\"properties\":{\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretName\":{\"default\":\"\",\"description\":\"secretName is the name of secret that contains Azure Storage Account Name and Key\",\"type\":\"string\"},\"shareName\":{\"default\":\"\",\"description\":\"shareName is the azure share Name\",\"type\":\"string\"}},\"required\":[\"secretName\",\"shareName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CSIVolumeSource\":{\"description\":\"Represents a source location of a volume to mount, managed by an external CSI driver\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType to mount. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.\",\"type\":\"string\"},\"nodePublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"readOnly\":{\"description\":\"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).\",\"type\":\"boolean\"},\"volumeAttributes\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.\",\"type\":\"object\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Capabilities\":{\"description\":\"Adds and removes POSIX capabilities from running containers.\",\"properties\":{\"add\":{\"description\":\"Added capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"drop\":{\"description\":\"Removed capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.CephFSVolumeSource\":{\"description\":\"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"monitors\":{\"description\":\"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretFile\":{\"description\":\"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"description\":\"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CinderVolumeSource\":{\"description\":\"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ClusterTrustBundleProjection\":{\"description\":\"ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"name\":{\"description\":\"Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.\",\"type\":\"string\"},\"optional\":{\"description\":\"If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"Relative path from the volume root to write the bundle.\",\"type\":\"string\"},\"signerName\":{\"description\":\"Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapEnvSource\":{\"description\":\"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\\n\\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapKeySelector\":{\"description\":\"Selects a key from a ConfigMap.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key to select.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ConfigMapProjection\":{\"description\":\"Adapts a ConfigMap into a projected volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapVolumeSource\":{\"description\":\"Adapts a ConfigMap into a volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Container\":{\"description\":\"A single application container that you want to run within a pod.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.\",\"type\":\"string\"},\"ports\":{\"description\":\"List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \\\"0.0.0.0\\\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container. This field cannot be set on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \\\"Always\\\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \\\"Always\\\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \\\"sidecar\\\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerPort\":{\"description\":\"ContainerPort represents a network port in a single container.\",\"properties\":{\"containerPort\":{\"default\":0,\"description\":\"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.\",\"format\":\"int32\",\"type\":\"integer\"},\"hostIP\":{\"description\":\"What host IP to bind the external port to.\",\"type\":\"string\"},\"hostPort\":{\"description\":\"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.\",\"format\":\"int32\",\"type\":\"integer\"},\"name\":{\"description\":\"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.\",\"type\":\"string\"},\"protocol\":{\"default\":\"TCP\",\"description\":\"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \\\"TCP\\\".\",\"type\":\"string\"}},\"required\":[\"containerPort\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerResizePolicy\":{\"description\":\"ContainerResizePolicy represents resource resize policy for the container.\",\"properties\":{\"resourceName\":{\"default\":\"\",\"description\":\"Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.\",\"type\":\"string\"},\"restartPolicy\":{\"default\":\"\",\"description\":\"Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.\",\"type\":\"string\"}},\"required\":[\"resourceName\",\"restartPolicy\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRule\":{\"description\":\"ContainerRestartRule describes how a container exit is handled.\",\"properties\":{\"action\":{\"description\":\"Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \\\"Restart\\\" to restart the container.\",\"type\":\"string\"},\"exitCodes\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\"}},\"required\":[\"action\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\":{\"description\":\"ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.\",\"properties\":{\"operator\":{\"description\":\"Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\\n set of specified values.\\n- NotIn: the requirement is satisfied if the container exit code is\\n not in the set of specified values.\",\"type\":\"string\"},\"values\":{\"description\":\"Specifies the set of values to check for container exit codes. At most 255 elements are allowed.\",\"items\":{\"default\":0,\"format\":\"int32\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"required\":[\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIProjection\":{\"description\":\"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"Items is a list of DownwardAPIVolume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeFile\":{\"description\":\"DownwardAPIVolumeFile represents information to create the file containing the pod field\",\"properties\":{\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"mode\":{\"description\":\"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'\",\"type\":\"string\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeSource\":{\"description\":\"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"Items is a list of downward API volume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.EmptyDirVolumeSource\":{\"description\":\"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.\",\"properties\":{\"medium\":{\"description\":\"medium represents what type of storage medium should back this directory. The default is \\\"\\\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir\",\"type\":\"string\"},\"sizeLimit\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EnvFromSource\":{\"description\":\"EnvFromSource represents the source of a set of ConfigMaps or Secrets\",\"properties\":{\"configMapRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource\"},\"prefix\":{\"description\":\"Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecretEnvSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVar\":{\"description\":\"EnvVar represents an environment variable present in a Container.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"value\":{\"description\":\"Variable references \$(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \\\"\\\".\",\"type\":\"string\"},\"valueFrom\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EnvVarSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVarSource\":{\"description\":\"EnvVarSource represents a source for the value of an EnvVar.\",\"properties\":{\"configMapKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector\"},\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"fileKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.FileKeySelector\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"},\"secretKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecretKeySelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralContainer\":{\"description\":\"An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\\n\\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.\",\"type\":\"string\"},\"ports\":{\"description\":\"Ports are not allowed for ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"targetContainerName\":{\"description\":\"If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\\n\\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.\",\"type\":\"string\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralVolumeSource\":{\"description\":\"Represents an ephemeral volume that is handled by a normal storage driver.\",\"properties\":{\"volumeClaimTemplate\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ExecAction\":{\"description\":\"ExecAction describes a \\\"run in container\\\" action.\",\"properties\":{\"command\":{\"description\":\"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FCVolumeSource\":{\"description\":\"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"lun\":{\"description\":\"lun is Optional: FC target lun number\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"targetWWNs\":{\"description\":\"targetWWNs is Optional: FC target worldwide names (WWNs)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"wwids\":{\"description\":\"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FileKeySelector\":{\"description\":\"FileKeySelector selects a key of the env file.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.\",\"type\":\"string\"},\"optional\":{\"default\":false,\"description\":\"Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\\n\\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.\",\"type\":\"string\"},\"volumeName\":{\"default\":\"\",\"description\":\"The name of the volume mount containing the env file.\",\"type\":\"string\"}},\"required\":[\"volumeName\",\"path\",\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.FlexVolumeSource\":{\"description\":\"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default filesystem depends on FlexVolume script.\",\"type\":\"string\"},\"options\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"options is Optional: this field holds extra command options if any.\",\"type\":\"object\"},\"readOnly\":{\"description\":\"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FlockerVolumeSource\":{\"description\":\"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"datasetName\":{\"description\":\"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated\",\"type\":\"string\"},\"datasetUUID\":{\"description\":\"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in Google Compute Engine.\\n\\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"format\":\"int32\",\"type\":\"integer\"},\"pdName\":{\"default\":\"\",\"description\":\"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"boolean\"}},\"required\":[\"pdName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GRPCAction\":{\"description\":\"GRPCAction specifies an action involving a GRPC service.\",\"properties\":{\"port\":{\"default\":0,\"description\":\"Port number of the gRPC service. Number must be in the range 1 to 65535.\",\"format\":\"int32\",\"type\":\"integer\"},\"service\":{\"default\":\"\",\"description\":\"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\\n\\nIf this is not specified, the default behavior is defined by gRPC.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GitRepoVolumeSource\":{\"description\":\"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\\n\\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.\",\"properties\":{\"directory\":{\"description\":\"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.\",\"type\":\"string\"},\"repository\":{\"default\":\"\",\"description\":\"repository is the URL\",\"type\":\"string\"},\"revision\":{\"description\":\"revision is the commit hash for the specified revision.\",\"type\":\"string\"}},\"required\":[\"repository\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GlusterfsVolumeSource\":{\"description\":\"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"endpoints\":{\"default\":\"\",\"description\":\"endpoints is the endpoint name that details Glusterfs topology.\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"boolean\"}},\"required\":[\"endpoints\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPGetAction\":{\"description\":\"HTTPGetAction describes an action based on HTTP Get requests.\",\"properties\":{\"host\":{\"description\":\"Host name to connect to, defaults to the pod IP. You probably want to set \\\"Host\\\" in httpHeaders instead.\",\"type\":\"string\"},\"httpHeaders\":{\"description\":\"Custom headers to set in the request. HTTP allows repeated headers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.HTTPHeader\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"Path to access on the HTTP server.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"scheme\":{\"description\":\"Scheme to use for connecting to the host. Defaults to HTTP.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPHeader\":{\"description\":\"HTTPHeader describes a custom header to be used in HTTP probes\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"The header field value\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostAlias\":{\"description\":\"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.\",\"properties\":{\"hostnames\":{\"description\":\"Hostnames for the above IP address.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ip\":{\"default\":\"\",\"description\":\"IP address of the host file entry.\",\"type\":\"string\"}},\"required\":[\"ip\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostPathVolumeSource\":{\"description\":\"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"},\"type\":{\"description\":\"type for HostPath Volume Defaults to \\\"\\\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ISCSIVolumeSource\":{\"description\":\"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.\",\"properties\":{\"chapAuthDiscovery\":{\"description\":\"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication\",\"type\":\"boolean\"},\"chapAuthSession\":{\"description\":\"chapAuthSession defines whether support iSCSI Session CHAP authentication\",\"type\":\"boolean\"},\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi\",\"type\":\"string\"},\"initiatorName\":{\"description\":\"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.\",\"type\":\"string\"},\"iqn\":{\"default\":\"\",\"description\":\"iqn is the target iSCSI Qualified Name.\",\"type\":\"string\"},\"iscsiInterface\":{\"default\":\"default\",\"description\":\"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).\",\"type\":\"string\"},\"lun\":{\"default\":0,\"description\":\"lun represents iSCSI Target Lun number.\",\"format\":\"int32\",\"type\":\"integer\"},\"portals\":{\"description\":\"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"targetPortal\":{\"default\":\"\",\"description\":\"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"type\":\"string\"}},\"required\":[\"targetPortal\",\"iqn\",\"lun\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ImageVolumeSource\":{\"description\":\"ImageVolumeSource represents a image volume resource.\",\"properties\":{\"pullPolicy\":{\"description\":\"Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.\",\"type\":\"string\"},\"reference\":{\"description\":\"Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.KeyToPath\":{\"description\":\"Maps a string key to a path within a volume.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the key to project.\",\"type\":\"string\"},\"mode\":{\"description\":\"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.\",\"type\":\"string\"}},\"required\":[\"key\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Lifecycle\":{\"description\":\"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.\",\"properties\":{\"postStart\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"preStop\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"stopSignal\":{\"description\":\"StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LifecycleHandler\":{\"description\":\"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"sleep\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SleepAction\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LocalObjectReference\":{\"description\":\"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NFSVolumeSource\":{\"description\":\"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"boolean\"},\"server\":{\"default\":\"\",\"description\":\"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"}},\"required\":[\"server\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeAffinity\":{\"description\":\"Node affinity is a group of node affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeSelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelector\":{\"description\":\"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.\",\"properties\":{\"nodeSelectorTerms\":{\"description\":\"Required. A list of node selector terms. The terms are ORed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"nodeSelectorTerms\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NodeSelectorRequirement\":{\"description\":\"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelectorTerm\":{\"description\":\"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\",\"properties\":{\"matchExpressions\":{\"description\":\"A list of node selector requirements by node's labels.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchFields\":{\"description\":\"A list of node selector requirements by node's fields.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ObjectFieldSelector\":{\"description\":\"ObjectFieldSelector selects an APIVersioned field of an object.\",\"properties\":{\"apiVersion\":{\"description\":\"Version of the schema the FieldPath is written in terms of, defaults to \\\"v1\\\".\",\"type\":\"string\"},\"fieldPath\":{\"default\":\"\",\"description\":\"Path of the field to select in the specified API version.\",\"type\":\"string\"}},\"required\":[\"fieldPath\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ObjectReference\":{\"description\":\"ObjectReference contains enough information to let you inspect or modify the referred object.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"fieldPath\":{\"description\":\"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \\\"spec.containers{name}\\\" (where \\\"name\\\" refers to the name of the container that triggered the event) or if no container name is specified \\\"spec.containers[2]\\\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.PersistentVolumeClaimSpec\":{\"description\":\"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"dataSource\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference\"},\"dataSourceRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.TypedObjectReference\"},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"storageClassName\":{\"description\":\"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1\",\"type\":\"string\"},\"volumeAttributesClassName\":{\"description\":\"volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\",\"type\":\"string\"},\"volumeMode\":{\"description\":\"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the binding reference to the PersistentVolume backing this claim.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimTemplate\":{\"description\":\"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec\"}},\"required\":[\"spec\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\":{\"description\":\"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).\",\"properties\":{\"claimName\":{\"default\":\"\",\"description\":\"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.\",\"type\":\"boolean\"}},\"required\":[\"claimName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\":{\"description\":\"Represents a Photon Controller persistent disk resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"pdID\":{\"default\":\"\",\"description\":\"pdID is the ID that identifies Photon Controller persistent disk\",\"type\":\"string\"}},\"required\":[\"pdID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodAffinity\":{\"description\":\"Pod affinity is a group of inter pod affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodAffinityTerm\":{\"description\":\"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"mismatchLabelKeys\":{\"description\":\"MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"namespaceSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"namespaces\":{\"description\":\"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \\\"this pod's namespace\\\".\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologyKey\":{\"default\":\"\",\"description\":\"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\",\"type\":\"string\"}},\"required\":[\"topologyKey\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodAntiAffinity\":{\"description\":\"Pod anti affinity is a group of inter pod anti affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \\\"weight\\\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodCertificateProjection\":{\"description\":\"PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.\",\"properties\":{\"certificateChainPath\":{\"description\":\"Write the certificate chain at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"credentialBundlePath\":{\"description\":\"Write the credential bundle at this path in the projected volume.\\n\\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\\n\\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\\n\\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.\",\"type\":\"string\"},\"keyPath\":{\"description\":\"Write the key at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"keyType\":{\"description\":\"The type of keypair Kubelet will generate for the pod.\\n\\nValid values are \\\"RSA3072\\\", \\\"RSA4096\\\", \\\"ECDSAP256\\\", \\\"ECDSAP384\\\", \\\"ECDSAP521\\\", and \\\"ED25519\\\".\",\"type\":\"string\"},\"maxExpirationSeconds\":{\"description\":\"maxExpirationSeconds is the maximum lifetime permitted for the certificate.\\n\\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\\n\\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\\n\\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.\",\"format\":\"int32\",\"type\":\"integer\"},\"signerName\":{\"description\":\"Kubelet's generated CSRs will be addressed to this signer.\",\"type\":\"string\"},\"userAnnotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\\n\\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\\n\\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\\n\\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.\",\"type\":\"object\"}},\"required\":[\"signerName\",\"keyType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfig\":{\"description\":\"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.\",\"properties\":{\"nameservers\":{\"description\":\"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"options\":{\"description\":\"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"searches\":{\"description\":\"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfigOption\":{\"description\":\"PodDNSConfigOption defines DNS resolver options of a pod.\",\"properties\":{\"name\":{\"description\":\"Name is this DNS resolver option's name. Required.\",\"type\":\"string\"},\"value\":{\"description\":\"Value is this DNS resolver option's value.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodOS\":{\"description\":\"PodOS defines the OS parameters of a pod.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodReadinessGate\":{\"description\":\"PodReadinessGate contains the reference to a pod condition\",\"properties\":{\"conditionType\":{\"default\":\"\",\"description\":\"ConditionType refers to a condition in the pod's condition list with matching type.\",\"type\":\"string\"}},\"required\":[\"conditionType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodResourceClaim\":{\"description\":\"PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\\n\\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.\",\"type\":\"string\"},\"resourceClaimName\":{\"description\":\"ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"},\"resourceClaimTemplateName\":{\"description\":\"ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\\n\\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\\n\\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSchedulingGate\":{\"description\":\"PodSchedulingGate is associated to a Pod to guard its scheduling.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the scheduling gate. Each scheduling gate must have a unique name field.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSecurityContext\":{\"description\":\"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.\",\"properties\":{\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"fsGroup\":{\"description\":\"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\\n\\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\\n\\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"fsGroupChangePolicy\":{\"description\":\"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \\\"OnRootMismatch\\\" and \\\"Always\\\". If not specified, \\\"Always\\\" is used. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxChangePolicy\":{\"description\":\"seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \\\"MountOption\\\" and \\\"Recursive\\\".\\n\\n\\\"Recursive\\\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\\n\\n\\\"MountOption\\\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \\\"MountOption\\\" value is allowed only when SELinuxMount feature gate is enabled.\\n\\nIf not specified and SELinuxMount feature gate is enabled, \\\"MountOption\\\" is used. If not specified and SELinuxMount feature gate is disabled, \\\"MountOption\\\" is used for ReadWriteOncePod volumes and \\\"Recursive\\\" for all other volumes.\\n\\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\\n\\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"supplementalGroups\":{\"description\":\"A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"default\":0,\"format\":\"int64\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"supplementalGroupsPolicy\":{\"description\":\"Defines how supplemental groups of the first container processes are calculated. Valid values are \\\"Merge\\\" and \\\"Strict\\\". If not specified, \\\"Merge\\\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"sysctls\":{\"description\":\"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Sysctl\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodSpec\":{\"description\":\"PodSpec is a description of a pod.\",\"properties\":{\"activeDeadlineSeconds\":{\"description\":\"Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.\",\"format\":\"int64\",\"type\":\"integer\"},\"affinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Affinity\"},\"automountServiceAccountToken\":{\"description\":\"AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.\",\"type\":\"boolean\"},\"containers\":{\"description\":\"List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"dnsConfig\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfig\"},\"dnsPolicy\":{\"description\":\"Set DNS policy for the pod. Defaults to \\\"ClusterFirst\\\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.\",\"type\":\"string\"},\"enableServiceLinks\":{\"description\":\"EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.\",\"type\":\"boolean\"},\"ephemeralContainers\":{\"description\":\"List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EphemeralContainer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostAliases\":{\"description\":\"HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.HostAlias\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"ip\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"ip\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostIPC\":{\"description\":\"Use the host's ipc namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostNetwork\":{\"description\":\"Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.\",\"type\":\"boolean\"},\"hostPID\":{\"description\":\"Use the host's pid namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostUsers\":{\"description\":\"Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.\",\"type\":\"boolean\"},\"hostname\":{\"description\":\"Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.\",\"type\":\"string\"},\"hostnameOverride\":{\"description\":\"HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\\n\\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.\",\"type\":\"string\"},\"imagePullSecrets\":{\"description\":\"ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"initContainers\":{\"description\":\"List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"nodeName\":{\"description\":\"NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename\",\"type\":\"string\"},\"nodeSelector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"os\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodOS\"},\"overhead\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md\",\"type\":\"object\"},\"preemptionPolicy\":{\"description\":\"PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.\",\"type\":\"string\"},\"priority\":{\"description\":\"The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.\",\"format\":\"int32\",\"type\":\"integer\"},\"priorityClassName\":{\"description\":\"If specified, indicates the pod's priority. \\\"system-node-critical\\\" and \\\"system-cluster-critical\\\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.\",\"type\":\"string\"},\"readinessGates\":{\"description\":\"If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \\\"True\\\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodReadinessGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resourceClaims\":{\"description\":\"ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\\n\\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\\n\\nThis field is immutable.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy\",\"type\":\"string\"},\"runtimeClassName\":{\"description\":\"RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \\\"legacy\\\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class\",\"type\":\"string\"},\"schedulerName\":{\"description\":\"If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.\",\"type\":\"string\"},\"schedulingGates\":{\"description\":\"SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\\n\\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodSecurityContext\"},\"serviceAccount\":{\"description\":\"DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.\",\"type\":\"string\"},\"serviceAccountName\":{\"description\":\"ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/\",\"type\":\"string\"},\"setHostnameAsFQDN\":{\"description\":\"If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\\\\\SYSTEM\\\\\\\\CurrentControlSet\\\\\\\\Services\\\\\\\\Tcpip\\\\\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.\",\"type\":\"boolean\"},\"shareProcessNamespace\":{\"description\":\"Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.\",\"type\":\"boolean\"},\"subdomain\":{\"description\":\"If specified, the fully qualified Pod hostname will be \\\"...svc.\\\". If not specified, the pod will not have a domainname at all.\",\"type\":\"string\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.\",\"format\":\"int64\",\"type\":\"integer\"},\"tolerations\":{\"description\":\"If specified, the pod's tolerations.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Toleration\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologySpreadConstraints\":{\"description\":\"TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"topologyKey\",\"whenUnsatisfiable\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"topologyKey\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumes\":{\"description\":\"List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Volume\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"workloadRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.WorkloadReference\"}},\"required\":[\"containers\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodTemplateSpec\":{\"description\":\"PodTemplateSpec describes the data a pod should have when created from a template\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodSpec\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PortworxVolumeSource\":{\"description\":\"PortworxVolumeSource represents a Portworx volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID uniquely identifies a Portworx volume\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PreferredSchedulingTerm\":{\"description\":\"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\",\"properties\":{\"preference\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"weight\":{\"default\":0,\"description\":\"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"preference\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Probe\":{\"description\":\"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"failureThreshold\":{\"description\":\"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"grpc\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.GRPCAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"initialDelaySeconds\":{\"description\":\"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"},\"periodSeconds\":{\"description\":\"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"successThreshold\":{\"description\":\"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.\",\"format\":\"int64\",\"type\":\"integer\"},\"timeoutSeconds\":{\"description\":\"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ProjectedVolumeSource\":{\"description\":\"Represents a projected volume source\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"sources\":{\"description\":\"sources is the list of volume projections. Each entry in this list handles one source.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VolumeProjection\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.QuobyteVolumeSource\":{\"description\":\"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"group\":{\"description\":\"group to map volume access to Default is no group\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.\",\"type\":\"boolean\"},\"registry\":{\"default\":\"\",\"description\":\"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes\",\"type\":\"string\"},\"tenant\":{\"description\":\"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin\",\"type\":\"string\"},\"user\":{\"description\":\"user to map volume access to Defaults to serivceaccount user\",\"type\":\"string\"},\"volume\":{\"default\":\"\",\"description\":\"volume is a string that references an already created Quobyte volume by name.\",\"type\":\"string\"}},\"required\":[\"registry\",\"volume\"],\"type\":\"object\"},\"io.k8s.api.core.v1.RBDVolumeSource\":{\"description\":\"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"keyring\":{\"default\":\"/etc/ceph/keyring\",\"description\":\"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"monitors\":{\"description\":\"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pool\":{\"default\":\"rbd\",\"description\":\"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"default\":\"admin\",\"description\":\"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\",\"image\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceClaim\":{\"description\":\"ResourceClaim references one entry in PodSpec.ResourceClaims.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.\",\"type\":\"string\"},\"request\":{\"description\":\"Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceFieldSelector\":{\"description\":\"ResourceFieldSelector represents container resources (cpu, memory) and their output format\",\"properties\":{\"containerName\":{\"description\":\"Container name: required for volumes, optional for env vars\",\"type\":\"string\"},\"divisor\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"resource\":{\"default\":\"\",\"description\":\"Required: resource to select\",\"type\":\"string\"}},\"required\":[\"resource\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ResourceRequirements\":{\"description\":\"ResourceRequirements describes the compute resource requirements.\",\"properties\":{\"claims\":{\"description\":\"Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\\n\\nThis field depends on the DynamicResourceAllocation feature gate.\\n\\nThis field is immutable. It can only be set for containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true},\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SELinuxOptions\":{\"description\":\"SELinuxOptions are the labels to be applied to the container\",\"properties\":{\"level\":{\"description\":\"Level is SELinux level label that applies to the container.\",\"type\":\"string\"},\"role\":{\"description\":\"Role is a SELinux role label that applies to the container.\",\"type\":\"string\"},\"type\":{\"description\":\"Type is a SELinux type label that applies to the container.\",\"type\":\"string\"},\"user\":{\"description\":\"User is a SELinux user label that applies to the container.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ScaleIOVolumeSource\":{\"description\":\"ScaleIOVolumeSource represents a persistent ScaleIO volume\",\"properties\":{\"fsType\":{\"default\":\"xfs\",\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Default is \\\"xfs\\\".\",\"type\":\"string\"},\"gateway\":{\"default\":\"\",\"description\":\"gateway is the host address of the ScaleIO API Gateway.\",\"type\":\"string\"},\"protectionDomain\":{\"description\":\"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"sslEnabled\":{\"description\":\"sslEnabled Flag enable/disable SSL communication with Gateway, default false\",\"type\":\"boolean\"},\"storageMode\":{\"default\":\"ThinProvisioned\",\"description\":\"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.\",\"type\":\"string\"},\"storagePool\":{\"description\":\"storagePool is the ScaleIO Storage Pool associated with the protection domain.\",\"type\":\"string\"},\"system\":{\"default\":\"\",\"description\":\"system is the name of the storage system as configured in ScaleIO.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.\",\"type\":\"string\"}},\"required\":[\"gateway\",\"system\",\"secretRef\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SeccompProfile\":{\"description\":\"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \\\"Localhost\\\". Must NOT be set for any other type.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of seccomp profile will be applied. Valid options are:\\n\\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.SecretEnvSource\":{\"description\":\"SecretEnvSource selects a Secret to populate the environment variables with.\\n\\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretKeySelector\":{\"description\":\"SecretKeySelector selects a key of a Secret.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key of the secret to select from. Must be a valid secret key.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.SecretProjection\":{\"description\":\"Adapts a secret into a projected volume.\\n\\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional field specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretVolumeSource\":{\"description\":\"Adapts a Secret into a volume.\\n\\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"optional\":{\"description\":\"optional field specify whether the Secret or its keys must be defined\",\"type\":\"boolean\"},\"secretName\":{\"description\":\"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecurityContext\":{\"description\":\"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.\",\"properties\":{\"allowPrivilegeEscalation\":{\"description\":\"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"capabilities\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.Capabilities\"},\"privileged\":{\"description\":\"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"procMount\":{\"description\":\"procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"readOnlyRootFilesystem\":{\"description\":\"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ServiceAccountTokenProjection\":{\"description\":\"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).\",\"properties\":{\"audience\":{\"description\":\"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.\",\"type\":\"string\"},\"expirationSeconds\":{\"description\":\"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.\",\"format\":\"int64\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the path relative to the mount point of the file to project the token into.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SleepAction\":{\"description\":\"SleepAction describes a \\\"sleep\\\" action.\",\"properties\":{\"seconds\":{\"default\":0,\"description\":\"Seconds is the number of seconds to sleep.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"seconds\"],\"type\":\"object\"},\"io.k8s.api.core.v1.StorageOSVolumeSource\":{\"description\":\"Represents a StorageOS persistent volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeName\":{\"description\":\"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.\",\"type\":\"string\"},\"volumeNamespace\":{\"description\":\"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \\\"default\\\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Sysctl\":{\"description\":\"Sysctl defines a kernel parameter to be set\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of a property to set\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"Value of a property to set\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TCPSocketAction\":{\"description\":\"TCPSocketAction describes an action based on opening a socket\",\"properties\":{\"host\":{\"description\":\"Optional: Host name to connect to, defaults to the pod IP.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Toleration\":{\"description\":\"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .\",\"properties\":{\"effect\":{\"description\":\"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\",\"type\":\"string\"},\"key\":{\"description\":\"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.\",\"type\":\"string\"},\"operator\":{\"description\":\"Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).\",\"type\":\"string\"},\"tolerationSeconds\":{\"description\":\"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.\",\"format\":\"int64\",\"type\":\"integer\"},\"value\":{\"description\":\"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.TopologySpreadConstraint\":{\"description\":\"TopologySpreadConstraint specifies how to spread matching pods among the given topology.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\\n\\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"maxSkew\":{\"default\":0,\"description\":\"MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.\",\"format\":\"int32\",\"type\":\"integer\"},\"minDomains\":{\"description\":\"MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \\\"global minimum\\\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\\n\\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \\\"global minimum\\\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\",\"format\":\"int32\",\"type\":\"integer\"},\"nodeAffinityPolicy\":{\"description\":\"NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\\n\\nIf this value is nil, the behavior is equivalent to the Honor policy.\",\"type\":\"string\"},\"nodeTaintsPolicy\":{\"description\":\"NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\\n\\nIf this value is nil, the behavior is equivalent to the Ignore policy.\",\"type\":\"string\"},\"topologyKey\":{\"default\":\"\",\"description\":\"TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \\\"bucket\\\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \\\"kubernetes.io/hostname\\\", each Node is a domain of that topology. And, if TopologyKey is \\\"topology.kubernetes.io/zone\\\", each zone is a domain of that topology. It's a required field.\",\"type\":\"string\"},\"whenUnsatisfiable\":{\"default\":\"\",\"description\":\"WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\\n but giving higher precedence to topologies that would help reduce the\\n skew.\\nA constraint is considered \\\"Unsatisfiable\\\" for an incoming pod if and only if every possible node assignment for that pod would violate \\\"MaxSkew\\\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.\",\"type\":\"string\"}},\"required\":[\"maxSkew\",\"topologyKey\",\"whenUnsatisfiable\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TypedLocalObjectReference\":{\"description\":\"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.TypedObjectReference\":{\"description\":\"TypedObjectReference contains enough information to let you locate the typed referenced object\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Volume\":{\"description\":\"Volume represents a named volume in a pod that may be accessed by any container in the pod.\",\"properties\":{\"awsElasticBlockStore\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\"},\"azureDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource\"},\"azureFile\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource\"},\"cephfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource\"},\"cinder\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource\"},\"csi\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource\"},\"emptyDir\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource\"},\"ephemeral\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource\"},\"fc\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.FCVolumeSource\"},\"flexVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource\"},\"flocker\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource\"},\"gcePersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\"},\"gitRepo\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource\"},\"glusterfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource\"},\"hostPath\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource\"},\"image\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource\"},\"iscsi\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource\"},\"name\":{\"default\":\"\",\"description\":\"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"nfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource\"},\"persistentVolumeClaim\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\"},\"photonPersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\"},\"portworxVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource\"},\"projected\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource\"},\"quobyte\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource\"},\"rbd\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource\"},\"scaleIO\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource\"},\"storageos\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource\"},\"vsphereVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeDevice\":{\"description\":\"volumeDevice describes a mapping of a raw block device within a container.\",\"properties\":{\"devicePath\":{\"default\":\"\",\"description\":\"devicePath is the path inside of the container that the device will be mapped to.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name must match the name of a persistentVolumeClaim in the pod\",\"type\":\"string\"}},\"required\":[\"name\",\"devicePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeMount\":{\"description\":\"VolumeMount describes a mounting of a Volume within a container.\",\"properties\":{\"mountPath\":{\"default\":\"\",\"description\":\"Path within the container at which the volume should be mounted. Must not contain ':'.\",\"type\":\"string\"},\"mountPropagation\":{\"description\":\"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"This must match the Name of a Volume.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.\",\"type\":\"boolean\"},\"recursiveReadOnly\":{\"description\":\"RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\\n\\nIf ReadOnly is false, this field has no meaning and must be unspecified.\\n\\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\\n\\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\\n\\nIf this field is not specified, it is treated as an equivalent of Disabled.\",\"type\":\"string\"},\"subPath\":{\"description\":\"Path within the volume from which the container's volume should be mounted. Defaults to \\\"\\\" (volume's root).\",\"type\":\"string\"},\"subPathExpr\":{\"description\":\"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references \$(VAR_NAME) are expanded using the container's environment. Defaults to \\\"\\\" (volume's root). SubPathExpr and SubPath are mutually exclusive.\",\"type\":\"string\"}},\"required\":[\"name\",\"mountPath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeProjection\":{\"description\":\"Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.\",\"properties\":{\"clusterTrustBundle\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection\"},\"podCertificate\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.SecretProjection\"},\"serviceAccountToken\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeResourceRequirements\":{\"description\":\"VolumeResourceRequirements describes the storage resource requirements for a volume.\",\"properties\":{\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\":{\"description\":\"Represents a vSphere volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"storagePolicyID\":{\"description\":\"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.\",\"type\":\"string\"},\"storagePolicyName\":{\"description\":\"storagePolicyName is the storage Policy Based Management (SPBM) profile name.\",\"type\":\"string\"},\"volumePath\":{\"default\":\"\",\"description\":\"volumePath is the path that identifies vSphere volume vmdk\",\"type\":\"string\"}},\"required\":[\"volumePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WeightedPodAffinityTerm\":{\"description\":\"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\",\"properties\":{\"podAffinityTerm\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"weight\":{\"default\":0,\"description\":\"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"podAffinityTerm\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WindowsSecurityContextOptions\":{\"description\":\"WindowsSecurityContextOptions contain Windows-specific options and credentials.\",\"properties\":{\"gmsaCredentialSpec\":{\"description\":\"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.\",\"type\":\"string\"},\"gmsaCredentialSpecName\":{\"description\":\"GMSACredentialSpecName is the name of the GMSA credential spec to use.\",\"type\":\"string\"},\"hostProcess\":{\"description\":\"HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.\",\"type\":\"boolean\"},\"runAsUserName\":{\"description\":\"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.WorkloadReference\":{\"description\":\"WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.\",\"type\":\"string\"},\"podGroup\":{\"default\":\"\",\"description\":\"PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.\",\"type\":\"string\"},\"podGroupReplicaKey\":{\"description\":\"PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.\",\"type\":\"string\"}},\"required\":[\"name\",\"podGroup\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.util.intstr.IntOrString\":{\"description\":\"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.\",\"format\":\"int-or-string\",\"oneOf\":[{\"type\":\"integer\"},{\"type\":\"string\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/batch/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getBatchV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"]}},\"/apis/batch/v1/cronjobs\":{\"get\":{\"description\":\"list or watch objects of kind CronJob\",\"operationId\":\"listBatchV1CronJobForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/jobs\":{\"get\":{\"description\":\"list or watch objects of kind Job\",\"operationId\":\"listBatchV1JobForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/namespaces/{namespace}/cronjobs\":{\"delete\":{\"description\":\"delete collection of CronJob\",\"operationId\":\"deleteBatchV1CollectionNamespacedCronJob\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CronJob\",\"operationId\":\"listBatchV1NamespacedCronJob\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJobList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CronJob\",\"operationId\":\"createBatchV1NamespacedCronJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}}},\"/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}\":{\"delete\":{\"description\":\"delete a CronJob\",\"operationId\":\"deleteBatchV1NamespacedCronJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CronJob\",\"operationId\":\"readBatchV1NamespacedCronJob\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CronJob\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CronJob\",\"operationId\":\"patchBatchV1NamespacedCronJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CronJob\",\"operationId\":\"replaceBatchV1NamespacedCronJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}}},\"/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status\":{\"get\":{\"description\":\"read status of the specified CronJob\",\"operationId\":\"readBatchV1NamespacedCronJobStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the CronJob\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified CronJob\",\"operationId\":\"patchBatchV1NamespacedCronJobStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified CronJob\",\"operationId\":\"replaceBatchV1NamespacedCronJobStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.CronJob\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}}},\"/apis/batch/v1/namespaces/{namespace}/jobs\":{\"delete\":{\"description\":\"delete collection of Job\",\"operationId\":\"deleteBatchV1CollectionNamespacedJob\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Job\",\"operationId\":\"listBatchV1NamespacedJob\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.JobList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Job\",\"operationId\":\"createBatchV1NamespacedJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}}},\"/apis/batch/v1/namespaces/{namespace}/jobs/{name}\":{\"delete\":{\"description\":\"delete a Job\",\"operationId\":\"deleteBatchV1NamespacedJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Job\",\"operationId\":\"readBatchV1NamespacedJob\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Job\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Job\",\"operationId\":\"patchBatchV1NamespacedJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Job\",\"operationId\":\"replaceBatchV1NamespacedJob\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}}},\"/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status\":{\"get\":{\"description\":\"read status of the specified Job\",\"operationId\":\"readBatchV1NamespacedJobStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Job\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Job\",\"operationId\":\"patchBatchV1NamespacedJobStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Job\",\"operationId\":\"replaceBatchV1NamespacedJobStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.api.batch.v1.Job\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}}},\"/apis/batch/v1/watch/cronjobs\":{\"get\":{\"description\":\"watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchBatchV1CronJobListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/watch/jobs\":{\"get\":{\"description\":\"watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchBatchV1JobListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/watch/namespaces/{namespace}/cronjobs\":{\"get\":{\"description\":\"watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchBatchV1NamespacedCronJobList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchBatchV1NamespacedCronJob\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"CronJob\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CronJob\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/watch/namespaces/{namespace}/jobs\":{\"get\":{\"description\":\"watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchBatchV1NamespacedJobList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchBatchV1NamespacedJob\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"batch_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"batch\",\"kind\":\"Job\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Job\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJob", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.Job", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement + containername::Union{Absent,Nothing,String} = ABSENT + operator::String + values::Union{Nothing,Vector{Int32}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement}, value) = _decode(IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement, value, true) +function _decode(::Type{IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement"), _openapi_raw, "decoding IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement") + _openapi_field_containername = haskey(_openapi_object, "containerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerName"], _openapi_validate) : ABSENT + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement"), _openapi_validate) + _openapi_field_values = _decode(Union{Nothing,Vector{Int32}}, _required(_openapi_object, "values", "IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerName","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement(; containername = _openapi_field_containername, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containername isa Absent || (_openapi_output["containerName"] = _encode(_openapi_value.containername)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement"), _openapi_output, "encoding IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.containername isa Absent || push!(_openapi_output, "containerName" => _openapi_value.containername) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern + status::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern}, value) = _decode(IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern, value, true) +function _decode(::Type{IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern"), _openapi_raw, "decoding IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern") + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern(; status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern"), _openapi_output, "encoding IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern) + _openapi_output = Pair{String,Any}[] + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1PodFailurePolicyRule + action::String + onexitcodes::Union{Absent,IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement,Nothing} = ABSENT + onpodconditions::Union{Absent,Union{Nothing,Vector{IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1PodFailurePolicyRule}, value) = _decode(IoK8sApiBatchV1PodFailurePolicyRule, value, true) +function _decode(::Type{IoK8sApiBatchV1PodFailurePolicyRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule"), _openapi_raw, "decoding IoK8sApiBatchV1PodFailurePolicyRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1PodFailurePolicyRule") + _openapi_field_action = _decode(String, _required(_openapi_object, "action", "IoK8sApiBatchV1PodFailurePolicyRule"), _openapi_validate) + _openapi_field_onexitcodes = haskey(_openapi_object, "onExitCodes") ? _decode(Union{Absent,IoK8sApiBatchV1PodFailurePolicyOnExitCodesRequirement,Nothing}, _openapi_object["onExitCodes"], _openapi_validate) : ABSENT + _openapi_field_onpodconditions = haskey(_openapi_object, "onPodConditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiBatchV1PodFailurePolicyOnPodConditionsPattern}}}, _openapi_object["onPodConditions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","onExitCodes","onPodConditions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1PodFailurePolicyRule(; action = _openapi_field_action, onexitcodes = _openapi_field_onexitcodes, onpodconditions = _openapi_field_onpodconditions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1PodFailurePolicyRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.onexitcodes isa Absent || (_openapi_output["onExitCodes"] = _encode(_openapi_value.onexitcodes)) + _openapi_value.onpodconditions isa Absent || (_openapi_output["onPodConditions"] = _encode(_openapi_value.onpodconditions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicyRule"), _openapi_output, "encoding IoK8sApiBatchV1PodFailurePolicyRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1PodFailurePolicyRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.onexitcodes isa Absent || push!(_openapi_output, "onExitCodes" => _openapi_value.onexitcodes) + _openapi_value.onpodconditions isa Absent || push!(_openapi_output, "onPodConditions" => _openapi_value.onpodconditions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1PodFailurePolicy + rules::Union{Nothing,Vector{IoK8sApiBatchV1PodFailurePolicyRule}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1PodFailurePolicy}, value) = _decode(IoK8sApiBatchV1PodFailurePolicy, value, true) +function _decode(::Type{IoK8sApiBatchV1PodFailurePolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy"), _openapi_raw, "decoding IoK8sApiBatchV1PodFailurePolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1PodFailurePolicy") + _openapi_field_rules = _decode(Union{Nothing,Vector{IoK8sApiBatchV1PodFailurePolicyRule}}, _required(_openapi_object, "rules", "IoK8sApiBatchV1PodFailurePolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("rules",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1PodFailurePolicy(; rules = _openapi_field_rules, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1PodFailurePolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.rules isa Absent || (_openapi_output["rules"] = _encode(_openapi_value.rules)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.PodFailurePolicy"), _openapi_output, "encoding IoK8sApiBatchV1PodFailurePolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1PodFailurePolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.rules isa Absent || push!(_openapi_output, "rules" => _openapi_value.rules) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1SuccessPolicyRule + succeededcount::Union{Absent,Int32,Nothing} = ABSENT + succeededindexes::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1SuccessPolicyRule}, value) = _decode(IoK8sApiBatchV1SuccessPolicyRule, value, true) +function _decode(::Type{IoK8sApiBatchV1SuccessPolicyRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule"), _openapi_raw, "decoding IoK8sApiBatchV1SuccessPolicyRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1SuccessPolicyRule") + _openapi_field_succeededcount = haskey(_openapi_object, "succeededCount") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["succeededCount"], _openapi_validate) : ABSENT + _openapi_field_succeededindexes = haskey(_openapi_object, "succeededIndexes") ? _decode(Union{Absent,Nothing,String}, _openapi_object["succeededIndexes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("succeededCount","succeededIndexes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1SuccessPolicyRule(; succeededcount = _openapi_field_succeededcount, succeededindexes = _openapi_field_succeededindexes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1SuccessPolicyRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.succeededcount isa Absent || (_openapi_output["succeededCount"] = _encode(_openapi_value.succeededcount)) + _openapi_value.succeededindexes isa Absent || (_openapi_output["succeededIndexes"] = _encode(_openapi_value.succeededindexes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicyRule"), _openapi_output, "encoding IoK8sApiBatchV1SuccessPolicyRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1SuccessPolicyRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.succeededcount isa Absent || push!(_openapi_output, "succeededCount" => _openapi_value.succeededcount) + _openapi_value.succeededindexes isa Absent || push!(_openapi_output, "succeededIndexes" => _openapi_value.succeededindexes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1SuccessPolicy + rules::Union{Nothing,Vector{IoK8sApiBatchV1SuccessPolicyRule}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1SuccessPolicy}, value) = _decode(IoK8sApiBatchV1SuccessPolicy, value, true) +function _decode(::Type{IoK8sApiBatchV1SuccessPolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicy"), _openapi_raw, "decoding IoK8sApiBatchV1SuccessPolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1SuccessPolicy") + _openapi_field_rules = _decode(Union{Nothing,Vector{IoK8sApiBatchV1SuccessPolicyRule}}, _required(_openapi_object, "rules", "IoK8sApiBatchV1SuccessPolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("rules",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1SuccessPolicy(; rules = _openapi_field_rules, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1SuccessPolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.rules isa Absent || (_openapi_output["rules"] = _encode(_openapi_value.rules)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.SuccessPolicy"), _openapi_output, "encoding IoK8sApiBatchV1SuccessPolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1SuccessPolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.rules isa Absent || push!(_openapi_output, "rules" => _openapi_value.rules) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, value) = _decode(IoK8sApiCoreV1NodeSelectorRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorTerm + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + matchfields::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, value) = _decode(IoK8sApiCoreV1NodeSelectorTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorTerm") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchfields = haskey(_openapi_object, "matchFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchFields"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchFields") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorTerm(; matchexpressions = _openapi_field_matchexpressions, matchfields = _openapi_field_matchfields, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchfields isa Absent || (_openapi_output["matchFields"] = _encode(_openapi_value.matchfields)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchfields isa Absent || push!(_openapi_output, "matchFields" => _openapi_value.matchfields) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PreferredSchedulingTerm + preference::IoK8sApiCoreV1NodeSelectorTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, value) = _decode(IoK8sApiCoreV1PreferredSchedulingTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PreferredSchedulingTerm") + _openapi_field_preference = _decode(IoK8sApiCoreV1NodeSelectorTerm, _required(_openapi_object, "preference", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preference","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PreferredSchedulingTerm(; preference = _openapi_field_preference, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preference isa Absent || (_openapi_output["preference"] = _encode(_openapi_value.preference)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_output, "encoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.preference isa Absent || push!(_openapi_output, "preference" => _openapi_value.preference) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelector + nodeselectorterms::Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelector}, value) = _decode(IoK8sApiCoreV1NodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelector") + _openapi_field_nodeselectorterms = _decode(Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}}, _required(_openapi_object, "nodeSelectorTerms", "IoK8sApiCoreV1NodeSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeSelectorTerms",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelector(; nodeselectorterms = _openapi_field_nodeselectorterms, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeselectorterms isa Absent || (_openapi_output["nodeSelectorTerms"] = _encode(_openapi_value.nodeselectorterms)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeselectorterms isa Absent || push!(_openapi_output, "nodeSelectorTerms" => _openapi_value.nodeselectorterms) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeAffinity}, value) = _decode(IoK8sApiCoreV1NodeAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_output, "encoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinityTerm + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + mismatchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + namespaceselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + namespaces::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + topologykey::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, value) = _decode(IoK8sApiCoreV1PodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinityTerm") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_mismatchlabelkeys = haskey(_openapi_object, "mismatchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mismatchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_namespaceselector = haskey(_openapi_object, "namespaceSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["namespaceSelector"], _openapi_validate) : ABSENT + _openapi_field_namespaces = haskey(_openapi_object, "namespaces") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["namespaces"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1PodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","mismatchLabelKeys","namespaceSelector","namespaces","topologyKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinityTerm(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, mismatchlabelkeys = _openapi_field_mismatchlabelkeys, namespaceselector = _openapi_field_namespaceselector, namespaces = _openapi_field_namespaces, topologykey = _openapi_field_topologykey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.mismatchlabelkeys isa Absent || (_openapi_output["mismatchLabelKeys"] = _encode(_openapi_value.mismatchlabelkeys)) + _openapi_value.namespaceselector isa Absent || (_openapi_output["namespaceSelector"] = _encode(_openapi_value.namespaceselector)) + _openapi_value.namespaces isa Absent || (_openapi_output["namespaces"] = _encode(_openapi_value.namespaces)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.mismatchlabelkeys isa Absent || push!(_openapi_output, "mismatchLabelKeys" => _openapi_value.mismatchlabelkeys) + _openapi_value.namespaceselector isa Absent || push!(_openapi_output, "namespaceSelector" => _openapi_value.namespaceselector) + _openapi_value.namespaces isa Absent || push!(_openapi_output, "namespaces" => _openapi_value.namespaces) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WeightedPodAffinityTerm + podaffinityterm::IoK8sApiCoreV1PodAffinityTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, value) = _decode(IoK8sApiCoreV1WeightedPodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WeightedPodAffinityTerm") + _openapi_field_podaffinityterm = _decode(IoK8sApiCoreV1PodAffinityTerm, _required(_openapi_object, "podAffinityTerm", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("podAffinityTerm","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WeightedPodAffinityTerm(; podaffinityterm = _openapi_field_podaffinityterm, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.podaffinityterm isa Absent || (_openapi_output["podAffinityTerm"] = _encode(_openapi_value.podaffinityterm)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.podaffinityterm isa Absent || push!(_openapi_output, "podAffinityTerm" => _openapi_value.podaffinityterm) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinity}, value) = _decode(IoK8sApiCoreV1PodAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAntiAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, value) = _decode(IoK8sApiCoreV1PodAntiAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAntiAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAntiAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Affinity + nodeaffinity::Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing} = ABSENT + podaffinity::Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing} = ABSENT + podantiaffinity::Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Affinity}, value) = _decode(IoK8sApiCoreV1Affinity, value, true) +function _decode(::Type{IoK8sApiCoreV1Affinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_raw, "decoding IoK8sApiCoreV1Affinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Affinity") + _openapi_field_nodeaffinity = haskey(_openapi_object, "nodeAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing}, _openapi_object["nodeAffinity"], _openapi_validate) : ABSENT + _openapi_field_podaffinity = haskey(_openapi_object, "podAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing}, _openapi_object["podAffinity"], _openapi_validate) : ABSENT + _openapi_field_podantiaffinity = haskey(_openapi_object, "podAntiAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing}, _openapi_object["podAntiAffinity"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeAffinity","podAffinity","podAntiAffinity") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Affinity(; nodeaffinity = _openapi_field_nodeaffinity, podaffinity = _openapi_field_podaffinity, podantiaffinity = _openapi_field_podantiaffinity, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeaffinity isa Absent || (_openapi_output["nodeAffinity"] = _encode(_openapi_value.nodeaffinity)) + _openapi_value.podaffinity isa Absent || (_openapi_output["podAffinity"] = _encode(_openapi_value.podaffinity)) + _openapi_value.podantiaffinity isa Absent || (_openapi_output["podAntiAffinity"] = _encode(_openapi_value.podantiaffinity)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_output, "encoding IoK8sApiCoreV1Affinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeaffinity isa Absent || push!(_openapi_output, "nodeAffinity" => _openapi_value.nodeaffinity) + _openapi_value.podaffinity isa Absent || push!(_openapi_output, "podAffinity" => _openapi_value.podaffinity) + _openapi_value.podantiaffinity isa Absent || push!(_openapi_output, "podAntiAffinity" => _openapi_value.podantiaffinity) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, value) = _decode(IoK8sApiCoreV1ConfigMapKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1ConfigMapKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectFieldSelector + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, value) = _decode(IoK8sApiCoreV1ObjectFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectFieldSelector") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = _decode(String, _required(_openapi_object, "fieldPath", "IoK8sApiCoreV1ObjectFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectFieldSelector(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FileKeySelector + key::String + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + volumename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FileKeySelector}, value) = _decode(IoK8sApiCoreV1FileKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1FileKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FileKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_volumename = _decode(String, _required(_openapi_object, "volumeName", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","optional","path","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FileKeySelector(; key = _openapi_field_key, optional = _openapi_field_optional, path = _openapi_field_path, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceFieldSelector + containername::Union{Absent,Nothing,String} = ABSENT + divisor::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + resource::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, value) = _decode(IoK8sApiCoreV1ResourceFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceFieldSelector") + _openapi_field_containername = haskey(_openapi_object, "containerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerName"], _openapi_validate) : ABSENT + _openapi_field_divisor = haskey(_openapi_object, "divisor") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["divisor"], _openapi_validate) : ABSENT + _openapi_field_resource = _decode(String, _required(_openapi_object, "resource", "IoK8sApiCoreV1ResourceFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerName","divisor","resource") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceFieldSelector(; containername = _openapi_field_containername, divisor = _openapi_field_divisor, resource = _openapi_field_resource, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containername isa Absent || (_openapi_output["containerName"] = _encode(_openapi_value.containername)) + _openapi_value.divisor isa Absent || (_openapi_output["divisor"] = _encode(_openapi_value.divisor)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.containername isa Absent || push!(_openapi_output, "containerName" => _openapi_value.containername) + _openapi_value.divisor isa Absent || push!(_openapi_output, "divisor" => _openapi_value.divisor) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretKeySelector}, value) = _decode(IoK8sApiCoreV1SecretKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1SecretKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVarSource + configmapkeyref::Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing} = ABSENT + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + filekeyref::Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing} = ABSENT + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + secretkeyref::Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVarSource}, value) = _decode(IoK8sApiCoreV1EnvVarSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVarSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVarSource") + _openapi_field_configmapkeyref = haskey(_openapi_object, "configMapKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing}, _openapi_object["configMapKeyRef"], _openapi_validate) : ABSENT + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_filekeyref = haskey(_openapi_object, "fileKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing}, _openapi_object["fileKeyRef"], _openapi_validate) : ABSENT + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_field_secretkeyref = haskey(_openapi_object, "secretKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing}, _openapi_object["secretKeyRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapKeyRef","fieldRef","fileKeyRef","resourceFieldRef","secretKeyRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVarSource(; configmapkeyref = _openapi_field_configmapkeyref, fieldref = _openapi_field_fieldref, filekeyref = _openapi_field_filekeyref, resourcefieldref = _openapi_field_resourcefieldref, secretkeyref = _openapi_field_secretkeyref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapkeyref isa Absent || (_openapi_output["configMapKeyRef"] = _encode(_openapi_value.configmapkeyref)) + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.filekeyref isa Absent || (_openapi_output["fileKeyRef"] = _encode(_openapi_value.filekeyref)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + _openapi_value.secretkeyref isa Absent || (_openapi_output["secretKeyRef"] = _encode(_openapi_value.secretkeyref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapkeyref isa Absent || push!(_openapi_output, "configMapKeyRef" => _openapi_value.configmapkeyref) + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.filekeyref isa Absent || push!(_openapi_output, "fileKeyRef" => _openapi_value.filekeyref) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + _openapi_value.secretkeyref isa Absent || push!(_openapi_output, "secretKeyRef" => _openapi_value.secretkeyref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVar + name::String + value::Union{Absent,Nothing,String} = ABSENT + valuefrom::Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVar}, value) = _decode(IoK8sApiCoreV1EnvVar, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVar}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVar"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVar") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EnvVar"), _openapi_validate) + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_field_valuefrom = haskey(_openapi_object, "valueFrom") ? _decode(Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing}, _openapi_object["valueFrom"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value","valueFrom") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVar(; name = _openapi_field_name, value = _openapi_field_value, valuefrom = _openapi_field_valuefrom, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + _openapi_value.valuefrom isa Absent || (_openapi_output["valueFrom"] = _encode(_openapi_value.valuefrom)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_output, "encoding IoK8sApiCoreV1EnvVar"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + _openapi_value.valuefrom isa Absent || push!(_openapi_output, "valueFrom" => _openapi_value.valuefrom) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, value) = _decode(IoK8sApiCoreV1ConfigMapEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretEnvSource}, value) = _decode(IoK8sApiCoreV1SecretEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvFromSource + configmapref::Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing} = ABSENT + prefix::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvFromSource}, value) = _decode(IoK8sApiCoreV1EnvFromSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvFromSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvFromSource") + _openapi_field_configmapref = haskey(_openapi_object, "configMapRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing}, _openapi_object["configMapRef"], _openapi_validate) : ABSENT + _openapi_field_prefix = haskey(_openapi_object, "prefix") ? _decode(Union{Absent,Nothing,String}, _openapi_object["prefix"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapRef","prefix","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvFromSource(; configmapref = _openapi_field_configmapref, prefix = _openapi_field_prefix, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapref isa Absent || (_openapi_output["configMapRef"] = _encode(_openapi_value.configmapref)) + _openapi_value.prefix isa Absent || (_openapi_output["prefix"] = _encode(_openapi_value.prefix)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapref isa Absent || push!(_openapi_output, "configMapRef" => _openapi_value.configmapref) + _openapi_value.prefix isa Absent || push!(_openapi_output, "prefix" => _openapi_value.prefix) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ExecAction + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ExecAction}, value) = _decode(IoK8sApiCoreV1ExecAction, value, true) +function _decode(::Type{IoK8sApiCoreV1ExecAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_raw, "decoding IoK8sApiCoreV1ExecAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ExecAction") + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("command",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ExecAction(; command = _openapi_field_command, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_output, "encoding IoK8sApiCoreV1ExecAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPHeader + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPHeader}, value) = _decode(IoK8sApiCoreV1HTTPHeader, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPHeader}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPHeader") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPHeader(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_output, "encoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgUtilIntstrIntOrString + value::Union{Int64,String} +end +_decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value) = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, value, true) +function _decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), value, "decoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(Int64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgUtilIntstrIntOrString")) + return IoK8sApimachineryPkgUtilIntstrIntOrString(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgUtilIntstrIntOrString) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), output, "encoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPGetAction + host::Union{Absent,Nothing,String} = ABSENT + httpheaders::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}} = ABSENT + path::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + scheme::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPGetAction}, value) = _decode(IoK8sApiCoreV1HTTPGetAction, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPGetAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPGetAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_httpheaders = haskey(_openapi_object, "httpHeaders") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}}, _openapi_object["httpHeaders"], _openapi_validate) : ABSENT + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1HTTPGetAction"), _openapi_validate) + _openapi_field_scheme = haskey(_openapi_object, "scheme") ? _decode(Union{Absent,Nothing,String}, _openapi_object["scheme"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","httpHeaders","path","port","scheme") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPGetAction(; host = _openapi_field_host, httpheaders = _openapi_field_httpheaders, path = _openapi_field_path, port = _openapi_field_port, scheme = _openapi_field_scheme, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.httpheaders isa Absent || (_openapi_output["httpHeaders"] = _encode(_openapi_value.httpheaders)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.scheme isa Absent || (_openapi_output["scheme"] = _encode(_openapi_value.scheme)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_output, "encoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.httpheaders isa Absent || push!(_openapi_output, "httpHeaders" => _openapi_value.httpheaders) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.scheme isa Absent || push!(_openapi_output, "scheme" => _openapi_value.scheme) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SleepAction + seconds::Int64 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SleepAction}, value) = _decode(IoK8sApiCoreV1SleepAction, value, true) +function _decode(::Type{IoK8sApiCoreV1SleepAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_raw, "decoding IoK8sApiCoreV1SleepAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SleepAction") + _openapi_field_seconds = _decode(Int64, _required(_openapi_object, "seconds", "IoK8sApiCoreV1SleepAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("seconds",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SleepAction(; seconds = _openapi_field_seconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.seconds isa Absent || (_openapi_output["seconds"] = _encode(_openapi_value.seconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_output, "encoding IoK8sApiCoreV1SleepAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.seconds isa Absent || push!(_openapi_output, "seconds" => _openapi_value.seconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TCPSocketAction + host::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TCPSocketAction}, value) = _decode(IoK8sApiCoreV1TCPSocketAction, value, true) +function _decode(::Type{IoK8sApiCoreV1TCPSocketAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_raw, "decoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TCPSocketAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1TCPSocketAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TCPSocketAction(; host = _openapi_field_host, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_output, "encoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LifecycleHandler + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + sleep::Union{Absent,IoK8sApiCoreV1SleepAction,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LifecycleHandler}, value) = _decode(IoK8sApiCoreV1LifecycleHandler, value, true) +function _decode(::Type{IoK8sApiCoreV1LifecycleHandler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_raw, "decoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LifecycleHandler") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_sleep = haskey(_openapi_object, "sleep") ? _decode(Union{Absent,IoK8sApiCoreV1SleepAction,Nothing}, _openapi_object["sleep"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","httpGet","sleep","tcpSocket") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LifecycleHandler(; exec = _openapi_field_exec, httpget = _openapi_field_httpget, sleep = _openapi_field_sleep, tcpsocket = _openapi_field_tcpsocket, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.sleep isa Absent || (_openapi_output["sleep"] = _encode(_openapi_value.sleep)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_output, "encoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.sleep isa Absent || push!(_openapi_output, "sleep" => _openapi_value.sleep) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Lifecycle + poststart::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + prestop::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + stopsignal::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Lifecycle}, value) = _decode(IoK8sApiCoreV1Lifecycle, value, true) +function _decode(::Type{IoK8sApiCoreV1Lifecycle}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_raw, "decoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Lifecycle") + _openapi_field_poststart = haskey(_openapi_object, "postStart") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["postStart"], _openapi_validate) : ABSENT + _openapi_field_prestop = haskey(_openapi_object, "preStop") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["preStop"], _openapi_validate) : ABSENT + _openapi_field_stopsignal = haskey(_openapi_object, "stopSignal") ? _decode(Union{Absent,Nothing,String}, _openapi_object["stopSignal"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("postStart","preStop","stopSignal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Lifecycle(; poststart = _openapi_field_poststart, prestop = _openapi_field_prestop, stopsignal = _openapi_field_stopsignal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.poststart isa Absent || (_openapi_output["postStart"] = _encode(_openapi_value.poststart)) + _openapi_value.prestop isa Absent || (_openapi_output["preStop"] = _encode(_openapi_value.prestop)) + _openapi_value.stopsignal isa Absent || (_openapi_output["stopSignal"] = _encode(_openapi_value.stopsignal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_output, "encoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = Pair{String,Any}[] + _openapi_value.poststart isa Absent || push!(_openapi_output, "postStart" => _openapi_value.poststart) + _openapi_value.prestop isa Absent || push!(_openapi_output, "preStop" => _openapi_value.prestop) + _openapi_value.stopsignal isa Absent || push!(_openapi_output, "stopSignal" => _openapi_value.stopsignal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GRPCAction + port::Int32 + service::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GRPCAction}, value) = _decode(IoK8sApiCoreV1GRPCAction, value, true) +function _decode(::Type{IoK8sApiCoreV1GRPCAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_raw, "decoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GRPCAction") + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1GRPCAction"), _openapi_validate) + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,Nothing,String}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("port","service") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GRPCAction(; port = _openapi_field_port, service = _openapi_field_service, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_output, "encoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Probe + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + failurethreshold::Union{Absent,Int32,Nothing} = ABSENT + grpc::Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + initialdelayseconds::Union{Absent,Int32,Nothing} = ABSENT + periodseconds::Union{Absent,Int32,Nothing} = ABSENT + successthreshold::Union{Absent,Int32,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + timeoutseconds::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Probe}, value) = _decode(IoK8sApiCoreV1Probe, value, true) +function _decode(::Type{IoK8sApiCoreV1Probe}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_raw, "decoding IoK8sApiCoreV1Probe"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Probe") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_failurethreshold = haskey(_openapi_object, "failureThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["failureThreshold"], _openapi_validate) : ABSENT + _openapi_field_grpc = haskey(_openapi_object, "grpc") ? _decode(Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing}, _openapi_object["grpc"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_initialdelayseconds = haskey(_openapi_object, "initialDelaySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["initialDelaySeconds"], _openapi_validate) : ABSENT + _openapi_field_periodseconds = haskey(_openapi_object, "periodSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["periodSeconds"], _openapi_validate) : ABSENT + _openapi_field_successthreshold = haskey(_openapi_object, "successThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["successThreshold"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_timeoutseconds = haskey(_openapi_object, "timeoutSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["timeoutSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","failureThreshold","grpc","httpGet","initialDelaySeconds","periodSeconds","successThreshold","tcpSocket","terminationGracePeriodSeconds","timeoutSeconds") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Probe(; exec = _openapi_field_exec, failurethreshold = _openapi_field_failurethreshold, grpc = _openapi_field_grpc, httpget = _openapi_field_httpget, initialdelayseconds = _openapi_field_initialdelayseconds, periodseconds = _openapi_field_periodseconds, successthreshold = _openapi_field_successthreshold, tcpsocket = _openapi_field_tcpsocket, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, timeoutseconds = _openapi_field_timeoutseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.failurethreshold isa Absent || (_openapi_output["failureThreshold"] = _encode(_openapi_value.failurethreshold)) + _openapi_value.grpc isa Absent || (_openapi_output["grpc"] = _encode(_openapi_value.grpc)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.initialdelayseconds isa Absent || (_openapi_output["initialDelaySeconds"] = _encode(_openapi_value.initialdelayseconds)) + _openapi_value.periodseconds isa Absent || (_openapi_output["periodSeconds"] = _encode(_openapi_value.periodseconds)) + _openapi_value.successthreshold isa Absent || (_openapi_output["successThreshold"] = _encode(_openapi_value.successthreshold)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.timeoutseconds isa Absent || (_openapi_output["timeoutSeconds"] = _encode(_openapi_value.timeoutseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_output, "encoding IoK8sApiCoreV1Probe"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.failurethreshold isa Absent || push!(_openapi_output, "failureThreshold" => _openapi_value.failurethreshold) + _openapi_value.grpc isa Absent || push!(_openapi_output, "grpc" => _openapi_value.grpc) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.initialdelayseconds isa Absent || push!(_openapi_output, "initialDelaySeconds" => _openapi_value.initialdelayseconds) + _openapi_value.periodseconds isa Absent || push!(_openapi_output, "periodSeconds" => _openapi_value.periodseconds) + _openapi_value.successthreshold isa Absent || push!(_openapi_output, "successThreshold" => _openapi_value.successthreshold) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.timeoutseconds isa Absent || push!(_openapi_output, "timeoutSeconds" => _openapi_value.timeoutseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerPort + containerport::Int32 + hostip::Union{Absent,Nothing,String} = ABSENT + hostport::Union{Absent,Int32,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerPort}, value) = _decode(IoK8sApiCoreV1ContainerPort, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerPort") + _openapi_field_containerport = _decode(Int32, _required(_openapi_object, "containerPort", "IoK8sApiCoreV1ContainerPort"), _openapi_validate) + _openapi_field_hostip = haskey(_openapi_object, "hostIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostIP"], _openapi_validate) : ABSENT + _openapi_field_hostport = haskey(_openapi_object, "hostPort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["hostPort"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerPort","hostIP","hostPort","name","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerPort(; containerport = _openapi_field_containerport, hostip = _openapi_field_hostip, hostport = _openapi_field_hostport, name = _openapi_field_name, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerport isa Absent || (_openapi_output["containerPort"] = _encode(_openapi_value.containerport)) + _openapi_value.hostip isa Absent || (_openapi_output["hostIP"] = _encode(_openapi_value.hostip)) + _openapi_value.hostport isa Absent || (_openapi_output["hostPort"] = _encode(_openapi_value.hostport)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_output, "encoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerport isa Absent || push!(_openapi_output, "containerPort" => _openapi_value.containerport) + _openapi_value.hostip isa Absent || push!(_openapi_output, "hostIP" => _openapi_value.hostip) + _openapi_value.hostport isa Absent || push!(_openapi_output, "hostPort" => _openapi_value.hostport) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerResizePolicy + resourcename::String + restartpolicy::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, value) = _decode(IoK8sApiCoreV1ContainerResizePolicy, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerResizePolicy") + _openapi_field_resourcename = _decode(String, _required(_openapi_object, "resourceName", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_field_restartpolicy = _decode(String, _required(_openapi_object, "restartPolicy", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceName","restartPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerResizePolicy(; resourcename = _openapi_field_resourcename, restartpolicy = _openapi_field_restartpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourcename isa Absent || (_openapi_output["resourceName"] = _encode(_openapi_value.resourcename)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_output, "encoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourcename isa Absent || push!(_openapi_output, "resourceName" => _openapi_value.resourcename) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceClaim + name::String + request::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceClaim}, value) = _decode(IoK8sApiCoreV1ResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ResourceClaim"), _openapi_validate) + _openapi_field_request = haskey(_openapi_object, "request") ? _decode(Union{Absent,Nothing,String}, _openapi_object["request"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","request") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceClaim(; name = _openapi_field_name, request = _openapi_field_request, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.request isa Absent || (_openapi_output["request"] = _encode(_openapi_value.request)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.request isa Absent || push!(_openapi_output, "request" => _openapi_value.request) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirements + claims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}} = ABSENT + limits::Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirements}, value) = _decode(IoK8sApiCoreV1ResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirements") + _openapi_field_claims = haskey(_openapi_object, "claims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}}, _openapi_object["claims"], _openapi_validate) : ABSENT + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claims","limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirements(; claims = _openapi_field_claims, limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claims isa Absent || (_openapi_output["claims"] = _encode(_openapi_value.claims)) + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.claims isa Absent || push!(_openapi_output, "claims" => _openapi_value.claims) + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRuleOnExitCodes + operator::String + values::Union{Absent,Union{Nothing,Vector{Int32}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, value) = _decode(IoK8sApiCoreV1ContainerRestartRuleOnExitCodes, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes") + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{Int32}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRuleOnExitCodes(; operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = Pair{String,Any}[] + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRule + action::String + exitcodes::Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, value) = _decode(IoK8sApiCoreV1ContainerRestartRule, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRule") + _openapi_field_action = _decode(String, _required(_openapi_object, "action", "IoK8sApiCoreV1ContainerRestartRule"), _openapi_validate) + _openapi_field_exitcodes = haskey(_openapi_object, "exitCodes") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing}, _openapi_object["exitCodes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","exitCodes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRule(; action = _openapi_field_action, exitcodes = _openapi_field_exitcodes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.exitcodes isa Absent || (_openapi_output["exitCodes"] = _encode(_openapi_value.exitcodes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.exitcodes isa Absent || push!(_openapi_output, "exitCodes" => _openapi_value.exitcodes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AppArmorProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AppArmorProfile}, value) = _decode(IoK8sApiCoreV1AppArmorProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1AppArmorProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_raw, "decoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AppArmorProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1AppArmorProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AppArmorProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_output, "encoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Capabilities + add::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + drop::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Capabilities}, value) = _decode(IoK8sApiCoreV1Capabilities, value, true) +function _decode(::Type{IoK8sApiCoreV1Capabilities}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_raw, "decoding IoK8sApiCoreV1Capabilities"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Capabilities") + _openapi_field_add = haskey(_openapi_object, "add") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["add"], _openapi_validate) : ABSENT + _openapi_field_drop = haskey(_openapi_object, "drop") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["drop"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("add","drop") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Capabilities(; add = _openapi_field_add, drop = _openapi_field_drop, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.add isa Absent || (_openapi_output["add"] = _encode(_openapi_value.add)) + _openapi_value.drop isa Absent || (_openapi_output["drop"] = _encode(_openapi_value.drop)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_output, "encoding IoK8sApiCoreV1Capabilities"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = Pair{String,Any}[] + _openapi_value.add isa Absent || push!(_openapi_output, "add" => _openapi_value.add) + _openapi_value.drop isa Absent || push!(_openapi_output, "drop" => _openapi_value.drop) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SELinuxOptions + level::Union{Absent,Nothing,String} = ABSENT + role::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SELinuxOptions}, value) = _decode(IoK8sApiCoreV1SELinuxOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1SELinuxOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_raw, "decoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SELinuxOptions") + _openapi_field_level = haskey(_openapi_object, "level") ? _decode(Union{Absent,Nothing,String}, _openapi_object["level"], _openapi_validate) : ABSENT + _openapi_field_role = haskey(_openapi_object, "role") ? _decode(Union{Absent,Nothing,String}, _openapi_object["role"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("level","role","type","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SELinuxOptions(; level = _openapi_field_level, role = _openapi_field_role, type_ = _openapi_field_type_, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.level isa Absent || (_openapi_output["level"] = _encode(_openapi_value.level)) + _openapi_value.role isa Absent || (_openapi_output["role"] = _encode(_openapi_value.role)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_output, "encoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.level isa Absent || push!(_openapi_output, "level" => _openapi_value.level) + _openapi_value.role isa Absent || push!(_openapi_output, "role" => _openapi_value.role) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SeccompProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SeccompProfile}, value) = _decode(IoK8sApiCoreV1SeccompProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1SeccompProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_raw, "decoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SeccompProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1SeccompProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SeccompProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_output, "encoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WindowsSecurityContextOptions + gmsacredentialspec::Union{Absent,Nothing,String} = ABSENT + gmsacredentialspecname::Union{Absent,Nothing,String} = ABSENT + hostprocess::Union{Absent,Bool,Nothing} = ABSENT + runasusername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, value) = _decode(IoK8sApiCoreV1WindowsSecurityContextOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_raw, "decoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WindowsSecurityContextOptions") + _openapi_field_gmsacredentialspec = haskey(_openapi_object, "gmsaCredentialSpec") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpec"], _openapi_validate) : ABSENT + _openapi_field_gmsacredentialspecname = haskey(_openapi_object, "gmsaCredentialSpecName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpecName"], _openapi_validate) : ABSENT + _openapi_field_hostprocess = haskey(_openapi_object, "hostProcess") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostProcess"], _openapi_validate) : ABSENT + _openapi_field_runasusername = haskey(_openapi_object, "runAsUserName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runAsUserName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("gmsaCredentialSpec","gmsaCredentialSpecName","hostProcess","runAsUserName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WindowsSecurityContextOptions(; gmsacredentialspec = _openapi_field_gmsacredentialspec, gmsacredentialspecname = _openapi_field_gmsacredentialspecname, hostprocess = _openapi_field_hostprocess, runasusername = _openapi_field_runasusername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.gmsacredentialspec isa Absent || (_openapi_output["gmsaCredentialSpec"] = _encode(_openapi_value.gmsacredentialspec)) + _openapi_value.gmsacredentialspecname isa Absent || (_openapi_output["gmsaCredentialSpecName"] = _encode(_openapi_value.gmsacredentialspecname)) + _openapi_value.hostprocess isa Absent || (_openapi_output["hostProcess"] = _encode(_openapi_value.hostprocess)) + _openapi_value.runasusername isa Absent || (_openapi_output["runAsUserName"] = _encode(_openapi_value.runasusername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_output, "encoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.gmsacredentialspec isa Absent || push!(_openapi_output, "gmsaCredentialSpec" => _openapi_value.gmsacredentialspec) + _openapi_value.gmsacredentialspecname isa Absent || push!(_openapi_output, "gmsaCredentialSpecName" => _openapi_value.gmsacredentialspecname) + _openapi_value.hostprocess isa Absent || push!(_openapi_output, "hostProcess" => _openapi_value.hostprocess) + _openapi_value.runasusername isa Absent || push!(_openapi_output, "runAsUserName" => _openapi_value.runasusername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecurityContext + allowprivilegeescalation::Union{Absent,Bool,Nothing} = ABSENT + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + capabilities::Union{Absent,IoK8sApiCoreV1Capabilities,Nothing} = ABSENT + privileged::Union{Absent,Bool,Nothing} = ABSENT + procmount::Union{Absent,Nothing,String} = ABSENT + readonlyrootfilesystem::Union{Absent,Bool,Nothing} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecurityContext}, value) = _decode(IoK8sApiCoreV1SecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1SecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecurityContext") + _openapi_field_allowprivilegeescalation = haskey(_openapi_object, "allowPrivilegeEscalation") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["allowPrivilegeEscalation"], _openapi_validate) : ABSENT + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_capabilities = haskey(_openapi_object, "capabilities") ? _decode(Union{Absent,IoK8sApiCoreV1Capabilities,Nothing}, _openapi_object["capabilities"], _openapi_validate) : ABSENT + _openapi_field_privileged = haskey(_openapi_object, "privileged") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["privileged"], _openapi_validate) : ABSENT + _openapi_field_procmount = haskey(_openapi_object, "procMount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["procMount"], _openapi_validate) : ABSENT + _openapi_field_readonlyrootfilesystem = haskey(_openapi_object, "readOnlyRootFilesystem") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnlyRootFilesystem"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allowPrivilegeEscalation","appArmorProfile","capabilities","privileged","procMount","readOnlyRootFilesystem","runAsGroup","runAsNonRoot","runAsUser","seLinuxOptions","seccompProfile","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecurityContext(; allowprivilegeescalation = _openapi_field_allowprivilegeescalation, apparmorprofile = _openapi_field_apparmorprofile, capabilities = _openapi_field_capabilities, privileged = _openapi_field_privileged, procmount = _openapi_field_procmount, readonlyrootfilesystem = _openapi_field_readonlyrootfilesystem, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allowprivilegeescalation isa Absent || (_openapi_output["allowPrivilegeEscalation"] = _encode(_openapi_value.allowprivilegeescalation)) + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.capabilities isa Absent || (_openapi_output["capabilities"] = _encode(_openapi_value.capabilities)) + _openapi_value.privileged isa Absent || (_openapi_output["privileged"] = _encode(_openapi_value.privileged)) + _openapi_value.procmount isa Absent || (_openapi_output["procMount"] = _encode(_openapi_value.procmount)) + _openapi_value.readonlyrootfilesystem isa Absent || (_openapi_output["readOnlyRootFilesystem"] = _encode(_openapi_value.readonlyrootfilesystem)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.allowprivilegeescalation isa Absent || push!(_openapi_output, "allowPrivilegeEscalation" => _openapi_value.allowprivilegeescalation) + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.capabilities isa Absent || push!(_openapi_output, "capabilities" => _openapi_value.capabilities) + _openapi_value.privileged isa Absent || push!(_openapi_output, "privileged" => _openapi_value.privileged) + _openapi_value.procmount isa Absent || push!(_openapi_output, "procMount" => _openapi_value.procmount) + _openapi_value.readonlyrootfilesystem isa Absent || push!(_openapi_output, "readOnlyRootFilesystem" => _openapi_value.readonlyrootfilesystem) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeDevice + devicepath::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeDevice}, value) = _decode(IoK8sApiCoreV1VolumeDevice, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeDevice}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeDevice") + _openapi_field_devicepath = _decode(String, _required(_openapi_object, "devicePath", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("devicePath","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeDevice(; devicepath = _openapi_field_devicepath, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.devicepath isa Absent || (_openapi_output["devicePath"] = _encode(_openapi_value.devicepath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_output, "encoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = Pair{String,Any}[] + _openapi_value.devicepath isa Absent || push!(_openapi_output, "devicePath" => _openapi_value.devicepath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeMount + mountpath::String + mountpropagation::Union{Absent,Nothing,String} = ABSENT + name::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + recursivereadonly::Union{Absent,Nothing,String} = ABSENT + subpath::Union{Absent,Nothing,String} = ABSENT + subpathexpr::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeMount}, value) = _decode(IoK8sApiCoreV1VolumeMount, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeMount}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeMount") + _openapi_field_mountpath = _decode(String, _required(_openapi_object, "mountPath", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_mountpropagation = haskey(_openapi_object, "mountPropagation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["mountPropagation"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_recursivereadonly = haskey(_openapi_object, "recursiveReadOnly") ? _decode(Union{Absent,Nothing,String}, _openapi_object["recursiveReadOnly"], _openapi_validate) : ABSENT + _openapi_field_subpath = haskey(_openapi_object, "subPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPath"], _openapi_validate) : ABSENT + _openapi_field_subpathexpr = haskey(_openapi_object, "subPathExpr") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPathExpr"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("mountPath","mountPropagation","name","readOnly","recursiveReadOnly","subPath","subPathExpr") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeMount(; mountpath = _openapi_field_mountpath, mountpropagation = _openapi_field_mountpropagation, name = _openapi_field_name, readonly = _openapi_field_readonly, recursivereadonly = _openapi_field_recursivereadonly, subpath = _openapi_field_subpath, subpathexpr = _openapi_field_subpathexpr, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.mountpath isa Absent || (_openapi_output["mountPath"] = _encode(_openapi_value.mountpath)) + _openapi_value.mountpropagation isa Absent || (_openapi_output["mountPropagation"] = _encode(_openapi_value.mountpropagation)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.recursivereadonly isa Absent || (_openapi_output["recursiveReadOnly"] = _encode(_openapi_value.recursivereadonly)) + _openapi_value.subpath isa Absent || (_openapi_output["subPath"] = _encode(_openapi_value.subpath)) + _openapi_value.subpathexpr isa Absent || (_openapi_output["subPathExpr"] = _encode(_openapi_value.subpathexpr)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_output, "encoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = Pair{String,Any}[] + _openapi_value.mountpath isa Absent || push!(_openapi_output, "mountPath" => _openapi_value.mountpath) + _openapi_value.mountpropagation isa Absent || push!(_openapi_output, "mountPropagation" => _openapi_value.mountpropagation) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.recursivereadonly isa Absent || push!(_openapi_output, "recursiveReadOnly" => _openapi_value.recursivereadonly) + _openapi_value.subpath isa Absent || push!(_openapi_output, "subPath" => _openapi_value.subpath) + _openapi_value.subpathexpr isa Absent || push!(_openapi_output, "subPathExpr" => _openapi_value.subpathexpr) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Container + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Container}, value) = _decode(IoK8sApiCoreV1Container, value, true) +function _decode(::Type{IoK8sApiCoreV1Container}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_raw, "decoding IoK8sApiCoreV1Container"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Container") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Container"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Container(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_output, "encoding IoK8sApiCoreV1Container"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfigOption + name::Union{Absent,Nothing,String} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, value) = _decode(IoK8sApiCoreV1PodDNSConfigOption, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfigOption") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfigOption(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfig + nameservers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + options::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}} = ABSENT + searches::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfig}, value) = _decode(IoK8sApiCoreV1PodDNSConfig, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfig") + _openapi_field_nameservers = haskey(_openapi_object, "nameservers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["nameservers"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_searches = haskey(_openapi_object, "searches") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["searches"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nameservers","options","searches") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfig(; nameservers = _openapi_field_nameservers, options = _openapi_field_options, searches = _openapi_field_searches, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nameservers isa Absent || (_openapi_output["nameservers"] = _encode(_openapi_value.nameservers)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.searches isa Absent || (_openapi_output["searches"] = _encode(_openapi_value.searches)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.nameservers isa Absent || push!(_openapi_output, "nameservers" => _openapi_value.nameservers) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.searches isa Absent || push!(_openapi_output, "searches" => _openapi_value.searches) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralContainer + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + targetcontainername::Union{Absent,Nothing,String} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralContainer}, value) = _decode(IoK8sApiCoreV1EphemeralContainer, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralContainer}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralContainer") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EphemeralContainer"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_targetcontainername = haskey(_openapi_object, "targetContainerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["targetContainerName"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","targetContainerName","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralContainer(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, targetcontainername = _openapi_field_targetcontainername, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.targetcontainername isa Absent || (_openapi_output["targetContainerName"] = _encode(_openapi_value.targetcontainername)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.targetcontainername isa Absent || push!(_openapi_output, "targetContainerName" => _openapi_value.targetcontainername) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostAlias + hostnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + ip::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostAlias}, value) = _decode(IoK8sApiCoreV1HostAlias, value, true) +function _decode(::Type{IoK8sApiCoreV1HostAlias}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_raw, "decoding IoK8sApiCoreV1HostAlias"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostAlias") + _openapi_field_hostnames = haskey(_openapi_object, "hostnames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["hostnames"], _openapi_validate) : ABSENT + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1HostAlias"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostnames","ip") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostAlias(; hostnames = _openapi_field_hostnames, ip = _openapi_field_ip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostnames isa Absent || (_openapi_output["hostnames"] = _encode(_openapi_value.hostnames)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_output, "encoding IoK8sApiCoreV1HostAlias"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostnames isa Absent || push!(_openapi_output, "hostnames" => _openapi_value.hostnames) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LocalObjectReference + name::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LocalObjectReference}, value) = _decode(IoK8sApiCoreV1LocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1LocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LocalObjectReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LocalObjectReference(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecNodeSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, value) = _decode(IoK8sApiCoreV1PodSpecNodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecNodeSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecNodeSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodOS + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodOS}, value) = _decode(IoK8sApiCoreV1PodOS, value, true) +function _decode(::Type{IoK8sApiCoreV1PodOS}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_raw, "decoding IoK8sApiCoreV1PodOS"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodOS") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodOS"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodOS(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_output, "encoding IoK8sApiCoreV1PodOS"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecOverhead + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, value) = _decode(IoK8sApiCoreV1PodSpecOverhead, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecOverhead") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecOverhead(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodReadinessGate + conditiontype::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodReadinessGate}, value) = _decode(IoK8sApiCoreV1PodReadinessGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodReadinessGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodReadinessGate") + _openapi_field_conditiontype = _decode(String, _required(_openapi_object, "conditionType", "IoK8sApiCoreV1PodReadinessGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditionType",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodReadinessGate(; conditiontype = _openapi_field_conditiontype, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditiontype isa Absent || (_openapi_output["conditionType"] = _encode(_openapi_value.conditiontype)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_output, "encoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditiontype isa Absent || push!(_openapi_output, "conditionType" => _openapi_value.conditiontype) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodResourceClaim + name::String + resourceclaimname::Union{Absent,Nothing,String} = ABSENT + resourceclaimtemplatename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodResourceClaim}, value) = _decode(IoK8sApiCoreV1PodResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1PodResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodResourceClaim"), _openapi_validate) + _openapi_field_resourceclaimname = haskey(_openapi_object, "resourceClaimName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimName"], _openapi_validate) : ABSENT + _openapi_field_resourceclaimtemplatename = haskey(_openapi_object, "resourceClaimTemplateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimTemplateName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","resourceClaimName","resourceClaimTemplateName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodResourceClaim(; name = _openapi_field_name, resourceclaimname = _openapi_field_resourceclaimname, resourceclaimtemplatename = _openapi_field_resourceclaimtemplatename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.resourceclaimname isa Absent || (_openapi_output["resourceClaimName"] = _encode(_openapi_value.resourceclaimname)) + _openapi_value.resourceclaimtemplatename isa Absent || (_openapi_output["resourceClaimTemplateName"] = _encode(_openapi_value.resourceclaimtemplatename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.resourceclaimname isa Absent || push!(_openapi_output, "resourceClaimName" => _openapi_value.resourceclaimname) + _openapi_value.resourceclaimtemplatename isa Absent || push!(_openapi_output, "resourceClaimTemplateName" => _openapi_value.resourceclaimtemplatename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSchedulingGate + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, value) = _decode(IoK8sApiCoreV1PodSchedulingGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSchedulingGate") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodSchedulingGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSchedulingGate(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_output, "encoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Sysctl + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Sysctl}, value) = _decode(IoK8sApiCoreV1Sysctl, value, true) +function _decode(::Type{IoK8sApiCoreV1Sysctl}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_raw, "decoding IoK8sApiCoreV1Sysctl"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Sysctl") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Sysctl(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_output, "encoding IoK8sApiCoreV1Sysctl"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSecurityContext + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + fsgroup::Union{Absent,Int64,Nothing} = ABSENT + fsgroupchangepolicy::Union{Absent,Nothing,String} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxchangepolicy::Union{Absent,Nothing,String} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + supplementalgroups::Union{Absent,Union{Nothing,Vector{Int64}}} = ABSENT + supplementalgroupspolicy::Union{Absent,Nothing,String} = ABSENT + sysctls::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSecurityContext}, value) = _decode(IoK8sApiCoreV1PodSecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSecurityContext") + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_fsgroup = haskey(_openapi_object, "fsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["fsGroup"], _openapi_validate) : ABSENT + _openapi_field_fsgroupchangepolicy = haskey(_openapi_object, "fsGroupChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsGroupChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxchangepolicy = haskey(_openapi_object, "seLinuxChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["seLinuxChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroups = haskey(_openapi_object, "supplementalGroups") ? _decode(Union{Absent,Union{Nothing,Vector{Int64}}}, _openapi_object["supplementalGroups"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroupspolicy = haskey(_openapi_object, "supplementalGroupsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["supplementalGroupsPolicy"], _openapi_validate) : ABSENT + _openapi_field_sysctls = haskey(_openapi_object, "sysctls") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}}, _openapi_object["sysctls"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appArmorProfile","fsGroup","fsGroupChangePolicy","runAsGroup","runAsNonRoot","runAsUser","seLinuxChangePolicy","seLinuxOptions","seccompProfile","supplementalGroups","supplementalGroupsPolicy","sysctls","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSecurityContext(; apparmorprofile = _openapi_field_apparmorprofile, fsgroup = _openapi_field_fsgroup, fsgroupchangepolicy = _openapi_field_fsgroupchangepolicy, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxchangepolicy = _openapi_field_selinuxchangepolicy, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, supplementalgroups = _openapi_field_supplementalgroups, supplementalgroupspolicy = _openapi_field_supplementalgroupspolicy, sysctls = _openapi_field_sysctls, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.fsgroup isa Absent || (_openapi_output["fsGroup"] = _encode(_openapi_value.fsgroup)) + _openapi_value.fsgroupchangepolicy isa Absent || (_openapi_output["fsGroupChangePolicy"] = _encode(_openapi_value.fsgroupchangepolicy)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxchangepolicy isa Absent || (_openapi_output["seLinuxChangePolicy"] = _encode(_openapi_value.selinuxchangepolicy)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.supplementalgroups isa Absent || (_openapi_output["supplementalGroups"] = _encode(_openapi_value.supplementalgroups)) + _openapi_value.supplementalgroupspolicy isa Absent || (_openapi_output["supplementalGroupsPolicy"] = _encode(_openapi_value.supplementalgroupspolicy)) + _openapi_value.sysctls isa Absent || (_openapi_output["sysctls"] = _encode(_openapi_value.sysctls)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.fsgroup isa Absent || push!(_openapi_output, "fsGroup" => _openapi_value.fsgroup) + _openapi_value.fsgroupchangepolicy isa Absent || push!(_openapi_output, "fsGroupChangePolicy" => _openapi_value.fsgroupchangepolicy) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxchangepolicy isa Absent || push!(_openapi_output, "seLinuxChangePolicy" => _openapi_value.selinuxchangepolicy) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.supplementalgroups isa Absent || push!(_openapi_output, "supplementalGroups" => _openapi_value.supplementalgroups) + _openapi_value.supplementalgroupspolicy isa Absent || push!(_openapi_output, "supplementalGroupsPolicy" => _openapi_value.supplementalgroupspolicy) + _openapi_value.sysctls isa Absent || push!(_openapi_output, "sysctls" => _openapi_value.sysctls) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Toleration + effect::Union{Absent,Nothing,String} = ABSENT + key::Union{Absent,Nothing,String} = ABSENT + operator::Union{Absent,Nothing,String} = ABSENT + tolerationseconds::Union{Absent,Int64,Nothing} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Toleration}, value) = _decode(IoK8sApiCoreV1Toleration, value, true) +function _decode(::Type{IoK8sApiCoreV1Toleration}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_raw, "decoding IoK8sApiCoreV1Toleration"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Toleration") + _openapi_field_effect = haskey(_openapi_object, "effect") ? _decode(Union{Absent,Nothing,String}, _openapi_object["effect"], _openapi_validate) : ABSENT + _openapi_field_key = haskey(_openapi_object, "key") ? _decode(Union{Absent,Nothing,String}, _openapi_object["key"], _openapi_validate) : ABSENT + _openapi_field_operator = haskey(_openapi_object, "operator") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operator"], _openapi_validate) : ABSENT + _openapi_field_tolerationseconds = haskey(_openapi_object, "tolerationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["tolerationSeconds"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("effect","key","operator","tolerationSeconds","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Toleration(; effect = _openapi_field_effect, key = _openapi_field_key, operator = _openapi_field_operator, tolerationseconds = _openapi_field_tolerationseconds, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.effect isa Absent || (_openapi_output["effect"] = _encode(_openapi_value.effect)) + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.tolerationseconds isa Absent || (_openapi_output["tolerationSeconds"] = _encode(_openapi_value.tolerationseconds)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_output, "encoding IoK8sApiCoreV1Toleration"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = Pair{String,Any}[] + _openapi_value.effect isa Absent || push!(_openapi_output, "effect" => _openapi_value.effect) + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.tolerationseconds isa Absent || push!(_openapi_output, "tolerationSeconds" => _openapi_value.tolerationseconds) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TopologySpreadConstraint + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + maxskew::Int32 + mindomains::Union{Absent,Int32,Nothing} = ABSENT + nodeaffinitypolicy::Union{Absent,Nothing,String} = ABSENT + nodetaintspolicy::Union{Absent,Nothing,String} = ABSENT + topologykey::String + whenunsatisfiable::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, value) = _decode(IoK8sApiCoreV1TopologySpreadConstraint, value, true) +function _decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_raw, "decoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TopologySpreadConstraint") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_maxskew = _decode(Int32, _required(_openapi_object, "maxSkew", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_mindomains = haskey(_openapi_object, "minDomains") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minDomains"], _openapi_validate) : ABSENT + _openapi_field_nodeaffinitypolicy = haskey(_openapi_object, "nodeAffinityPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeAffinityPolicy"], _openapi_validate) : ABSENT + _openapi_field_nodetaintspolicy = haskey(_openapi_object, "nodeTaintsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeTaintsPolicy"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_whenunsatisfiable = _decode(String, _required(_openapi_object, "whenUnsatisfiable", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","maxSkew","minDomains","nodeAffinityPolicy","nodeTaintsPolicy","topologyKey","whenUnsatisfiable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TopologySpreadConstraint(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, maxskew = _openapi_field_maxskew, mindomains = _openapi_field_mindomains, nodeaffinitypolicy = _openapi_field_nodeaffinitypolicy, nodetaintspolicy = _openapi_field_nodetaintspolicy, topologykey = _openapi_field_topologykey, whenunsatisfiable = _openapi_field_whenunsatisfiable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.maxskew isa Absent || (_openapi_output["maxSkew"] = _encode(_openapi_value.maxskew)) + _openapi_value.mindomains isa Absent || (_openapi_output["minDomains"] = _encode(_openapi_value.mindomains)) + _openapi_value.nodeaffinitypolicy isa Absent || (_openapi_output["nodeAffinityPolicy"] = _encode(_openapi_value.nodeaffinitypolicy)) + _openapi_value.nodetaintspolicy isa Absent || (_openapi_output["nodeTaintsPolicy"] = _encode(_openapi_value.nodetaintspolicy)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + _openapi_value.whenunsatisfiable isa Absent || (_openapi_output["whenUnsatisfiable"] = _encode(_openapi_value.whenunsatisfiable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_output, "encoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.maxskew isa Absent || push!(_openapi_output, "maxSkew" => _openapi_value.maxskew) + _openapi_value.mindomains isa Absent || push!(_openapi_output, "minDomains" => _openapi_value.mindomains) + _openapi_value.nodeaffinitypolicy isa Absent || push!(_openapi_output, "nodeAffinityPolicy" => _openapi_value.nodeaffinitypolicy) + _openapi_value.nodetaintspolicy isa Absent || push!(_openapi_output, "nodeTaintsPolicy" => _openapi_value.nodetaintspolicy) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + _openapi_value.whenunsatisfiable isa Absent || push!(_openapi_output, "whenUnsatisfiable" => _openapi_value.whenunsatisfiable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, value) = _decode(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureDiskVolumeSource + cachingmode::Union{Absent,Nothing,String} = ABSENT + diskname::String + diskuri::String + fstype::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureDiskVolumeSource") + _openapi_field_cachingmode = haskey(_openapi_object, "cachingMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["cachingMode"], _openapi_validate) : ABSENT + _openapi_field_diskname = _decode(String, _required(_openapi_object, "diskName", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_diskuri = _decode(String, _required(_openapi_object, "diskURI", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cachingMode","diskName","diskURI","fsType","kind","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureDiskVolumeSource(; cachingmode = _openapi_field_cachingmode, diskname = _openapi_field_diskname, diskuri = _openapi_field_diskuri, fstype = _openapi_field_fstype, kind = _openapi_field_kind, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cachingmode isa Absent || (_openapi_output["cachingMode"] = _encode(_openapi_value.cachingmode)) + _openapi_value.diskname isa Absent || (_openapi_output["diskName"] = _encode(_openapi_value.diskname)) + _openapi_value.diskuri isa Absent || (_openapi_output["diskURI"] = _encode(_openapi_value.diskuri)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.cachingmode isa Absent || push!(_openapi_output, "cachingMode" => _openapi_value.cachingmode) + _openapi_value.diskname isa Absent || push!(_openapi_output, "diskName" => _openapi_value.diskname) + _openapi_value.diskuri isa Absent || push!(_openapi_output, "diskURI" => _openapi_value.diskuri) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureFileVolumeSource + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretname::String + sharename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureFileVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureFileVolumeSource") + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretname = _decode(String, _required(_openapi_object, "secretName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_field_sharename = _decode(String, _required(_openapi_object, "shareName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("readOnly","secretName","shareName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureFileVolumeSource(; readonly = _openapi_field_readonly, secretname = _openapi_field_secretname, sharename = _openapi_field_sharename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + _openapi_value.sharename isa Absent || (_openapi_output["shareName"] = _encode(_openapi_value.sharename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + _openapi_value.sharename isa Absent || push!(_openapi_output, "shareName" => _openapi_value.sharename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CephFSVolumeSource + monitors::Union{Nothing,Vector{String}} + path::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretfile::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, value) = _decode(IoK8sApiCoreV1CephFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CephFSVolumeSource") + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1CephFSVolumeSource"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretfile = haskey(_openapi_object, "secretFile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretFile"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("monitors","path","readOnly","secretFile","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CephFSVolumeSource(; monitors = _openapi_field_monitors, path = _openapi_field_path, readonly = _openapi_field_readonly, secretfile = _openapi_field_secretfile, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretfile isa Absent || (_openapi_output["secretFile"] = _encode(_openapi_value.secretfile)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretfile isa Absent || push!(_openapi_output, "secretFile" => _openapi_value.secretfile) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CinderVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, value) = _decode(IoK8sApiCoreV1CinderVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CinderVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1CinderVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CinderVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1KeyToPath + key::String + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1KeyToPath}, value) = _decode(IoK8sApiCoreV1KeyToPath, value, true) +function _decode(::Type{IoK8sApiCoreV1KeyToPath}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_raw, "decoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1KeyToPath") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","mode","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1KeyToPath(; key = _openapi_field_key, mode = _openapi_field_mode, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_output, "encoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, value) = _decode(IoK8sApiCoreV1ConfigMapVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, value) = _decode(IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + nodepublishsecretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeattributes::Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, value) = _decode(IoK8sApiCoreV1CSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1CSIVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_nodepublishsecretref = haskey(_openapi_object, "nodePublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["nodePublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeattributes = haskey(_openapi_object, "volumeAttributes") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing}, _openapi_object["volumeAttributes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","nodePublishSecretRef","readOnly","volumeAttributes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, nodepublishsecretref = _openapi_field_nodepublishsecretref, readonly = _openapi_field_readonly, volumeattributes = _openapi_field_volumeattributes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.nodepublishsecretref isa Absent || (_openapi_output["nodePublishSecretRef"] = _encode(_openapi_value.nodepublishsecretref)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeattributes isa Absent || (_openapi_output["volumeAttributes"] = _encode(_openapi_value.volumeattributes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.nodepublishsecretref isa Absent || push!(_openapi_output, "nodePublishSecretRef" => _openapi_value.nodepublishsecretref) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeattributes isa Absent || push!(_openapi_output, "volumeAttributes" => _openapi_value.volumeattributes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeFile + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeFile, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeFile") + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1DownwardAPIVolumeFile"), _openapi_validate) + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fieldRef","mode","path","resourceFieldRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeFile(; fieldref = _openapi_field_fieldref, mode = _openapi_field_mode, path = _openapi_field_path, resourcefieldref = _openapi_field_resourcefieldref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = Pair{String,Any}[] + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EmptyDirVolumeSource + medium::Union{Absent,Nothing,String} = ABSENT + sizelimit::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, value) = _decode(IoK8sApiCoreV1EmptyDirVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EmptyDirVolumeSource") + _openapi_field_medium = haskey(_openapi_object, "medium") ? _decode(Union{Absent,Nothing,String}, _openapi_object["medium"], _openapi_validate) : ABSENT + _openapi_field_sizelimit = haskey(_openapi_object, "sizeLimit") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["sizeLimit"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("medium","sizeLimit") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EmptyDirVolumeSource(; medium = _openapi_field_medium, sizelimit = _openapi_field_sizelimit, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.medium isa Absent || (_openapi_output["medium"] = _encode(_openapi_value.medium)) + _openapi_value.sizelimit isa Absent || (_openapi_output["sizeLimit"] = _encode(_openapi_value.sizelimit)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.medium isa Absent || push!(_openapi_output, "medium" => _openapi_value.medium) + _openapi_value.sizelimit isa Absent || push!(_openapi_output, "sizeLimit" => _openapi_value.sizelimit) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedLocalObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, value) = _decode(IoK8sApiCoreV1TypedLocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedLocalObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedLocalObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedObjectReference}, value) = _decode(IoK8sApiCoreV1TypedObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirements + limits::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirements") + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirements(; limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimSpec + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + datasource::Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing} = ABSENT + datasourceref::Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing} = ABSENT + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + storageclassname::Union{Absent,Nothing,String} = ABSENT + volumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + volumemode::Union{Absent,Nothing,String} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimSpec") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_datasource = haskey(_openapi_object, "dataSource") ? _decode(Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing}, _openapi_object["dataSource"], _openapi_validate) : ABSENT + _openapi_field_datasourceref = haskey(_openapi_object, "dataSourceRef") ? _decode(Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing}, _openapi_object["dataSourceRef"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = haskey(_openapi_object, "storageClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageClassName"], _openapi_validate) : ABSENT + _openapi_field_volumeattributesclassname = haskey(_openapi_object, "volumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_volumemode = haskey(_openapi_object, "volumeMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeMode"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","dataSource","dataSourceRef","resources","selector","storageClassName","volumeAttributesClassName","volumeMode","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimSpec(; accessmodes = _openapi_field_accessmodes, datasource = _openapi_field_datasource, datasourceref = _openapi_field_datasourceref, resources = _openapi_field_resources, selector = _openapi_field_selector, storageclassname = _openapi_field_storageclassname, volumeattributesclassname = _openapi_field_volumeattributesclassname, volumemode = _openapi_field_volumemode, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.datasource isa Absent || (_openapi_output["dataSource"] = _encode(_openapi_value.datasource)) + _openapi_value.datasourceref isa Absent || (_openapi_output["dataSourceRef"] = _encode(_openapi_value.datasourceref)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + _openapi_value.volumeattributesclassname isa Absent || (_openapi_output["volumeAttributesClassName"] = _encode(_openapi_value.volumeattributesclassname)) + _openapi_value.volumemode isa Absent || (_openapi_output["volumeMode"] = _encode(_openapi_value.volumemode)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.datasource isa Absent || push!(_openapi_output, "dataSource" => _openapi_value.datasource) + _openapi_value.datasourceref isa Absent || push!(_openapi_output, "dataSourceRef" => _openapi_value.datasourceref) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + _openapi_value.volumeattributesclassname isa Absent || push!(_openapi_output, "volumeAttributesClassName" => _openapi_value.volumeattributesclassname) + _openapi_value.volumemode isa Absent || push!(_openapi_output, "volumeMode" => _openapi_value.volumemode) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimTemplate + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiCoreV1PersistentVolumeClaimSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimTemplate, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimTemplate") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, _required(_openapi_object, "spec", "IoK8sApiCoreV1PersistentVolumeClaimTemplate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimTemplate(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralVolumeSource + volumeclaimtemplate::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, value) = _decode(IoK8sApiCoreV1EphemeralVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralVolumeSource") + _openapi_field_volumeclaimtemplate = haskey(_openapi_object, "volumeClaimTemplate") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing}, _openapi_object["volumeClaimTemplate"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("volumeClaimTemplate",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralVolumeSource(; volumeclaimtemplate = _openapi_field_volumeclaimtemplate, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.volumeclaimtemplate isa Absent || (_openapi_output["volumeClaimTemplate"] = _encode(_openapi_value.volumeclaimtemplate)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.volumeclaimtemplate isa Absent || push!(_openapi_output, "volumeClaimTemplate" => _openapi_value.volumeclaimtemplate) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FCVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + lun::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + targetwwns::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + wwids::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FCVolumeSource}, value) = _decode(IoK8sApiCoreV1FCVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FCVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FCVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_lun = haskey(_openapi_object, "lun") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["lun"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_targetwwns = haskey(_openapi_object, "targetWWNs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["targetWWNs"], _openapi_validate) : ABSENT + _openapi_field_wwids = haskey(_openapi_object, "wwids") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["wwids"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","lun","readOnly","targetWWNs","wwids") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FCVolumeSource(; fstype = _openapi_field_fstype, lun = _openapi_field_lun, readonly = _openapi_field_readonly, targetwwns = _openapi_field_targetwwns, wwids = _openapi_field_wwids, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.targetwwns isa Absent || (_openapi_output["targetWWNs"] = _encode(_openapi_value.targetwwns)) + _openapi_value.wwids isa Absent || (_openapi_output["wwids"] = _encode(_openapi_value.wwids)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.targetwwns isa Absent || push!(_openapi_output, "targetWWNs" => _openapi_value.targetwwns) + _openapi_value.wwids isa Absent || push!(_openapi_output, "wwids" => _openapi_value.wwids) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSourceOptions + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, value) = _decode(IoK8sApiCoreV1FlexVolumeSourceOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSourceOptions") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSourceOptions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + options::Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, value) = _decode(IoK8sApiCoreV1FlexVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1FlexVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","options","readOnly","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, options = _openapi_field_options, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlockerVolumeSource + datasetname::Union{Absent,Nothing,String} = ABSENT + datasetuuid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, value) = _decode(IoK8sApiCoreV1FlockerVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlockerVolumeSource") + _openapi_field_datasetname = haskey(_openapi_object, "datasetName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetName"], _openapi_validate) : ABSENT + _openapi_field_datasetuuid = haskey(_openapi_object, "datasetUUID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetUUID"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("datasetName","datasetUUID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlockerVolumeSource(; datasetname = _openapi_field_datasetname, datasetuuid = _openapi_field_datasetuuid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.datasetname isa Absent || (_openapi_output["datasetName"] = _encode(_openapi_value.datasetname)) + _openapi_value.datasetuuid isa Absent || (_openapi_output["datasetUUID"] = _encode(_openapi_value.datasetuuid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.datasetname isa Absent || push!(_openapi_output, "datasetName" => _openapi_value.datasetname) + _openapi_value.datasetuuid isa Absent || push!(_openapi_output, "datasetUUID" => _openapi_value.datasetuuid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GCEPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + pdname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GCEPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_pdname = _decode(String, _required(_openapi_object, "pdName", "IoK8sApiCoreV1GCEPersistentDiskVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","pdName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GCEPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, pdname = _openapi_field_pdname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.pdname isa Absent || (_openapi_output["pdName"] = _encode(_openapi_value.pdname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.pdname isa Absent || push!(_openapi_output, "pdName" => _openapi_value.pdname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GitRepoVolumeSource + directory::Union{Absent,Nothing,String} = ABSENT + repository::String + revision::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, value) = _decode(IoK8sApiCoreV1GitRepoVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GitRepoVolumeSource") + _openapi_field_directory = haskey(_openapi_object, "directory") ? _decode(Union{Absent,Nothing,String}, _openapi_object["directory"], _openapi_validate) : ABSENT + _openapi_field_repository = _decode(String, _required(_openapi_object, "repository", "IoK8sApiCoreV1GitRepoVolumeSource"), _openapi_validate) + _openapi_field_revision = haskey(_openapi_object, "revision") ? _decode(Union{Absent,Nothing,String}, _openapi_object["revision"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("directory","repository","revision") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GitRepoVolumeSource(; directory = _openapi_field_directory, repository = _openapi_field_repository, revision = _openapi_field_revision, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.directory isa Absent || (_openapi_output["directory"] = _encode(_openapi_value.directory)) + _openapi_value.repository isa Absent || (_openapi_output["repository"] = _encode(_openapi_value.repository)) + _openapi_value.revision isa Absent || (_openapi_output["revision"] = _encode(_openapi_value.revision)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.directory isa Absent || push!(_openapi_output, "directory" => _openapi_value.directory) + _openapi_value.repository isa Absent || push!(_openapi_output, "repository" => _openapi_value.repository) + _openapi_value.revision isa Absent || push!(_openapi_output, "revision" => _openapi_value.revision) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GlusterfsVolumeSource + endpoints::String + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, value) = _decode(IoK8sApiCoreV1GlusterfsVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GlusterfsVolumeSource") + _openapi_field_endpoints = _decode(String, _required(_openapi_object, "endpoints", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endpoints","path","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GlusterfsVolumeSource(; endpoints = _openapi_field_endpoints, path = _openapi_field_path, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostPathVolumeSource + path::String + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, value) = _decode(IoK8sApiCoreV1HostPathVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostPathVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1HostPathVolumeSource"), _openapi_validate) + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostPathVolumeSource(; path = _openapi_field_path, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ImageVolumeSource + pullpolicy::Union{Absent,Nothing,String} = ABSENT + reference::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, value) = _decode(IoK8sApiCoreV1ImageVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ImageVolumeSource") + _openapi_field_pullpolicy = haskey(_openapi_object, "pullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pullPolicy"], _openapi_validate) : ABSENT + _openapi_field_reference = haskey(_openapi_object, "reference") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reference"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("pullPolicy","reference") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ImageVolumeSource(; pullpolicy = _openapi_field_pullpolicy, reference = _openapi_field_reference, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.pullpolicy isa Absent || (_openapi_output["pullPolicy"] = _encode(_openapi_value.pullpolicy)) + _openapi_value.reference isa Absent || (_openapi_output["reference"] = _encode(_openapi_value.reference)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.pullpolicy isa Absent || push!(_openapi_output, "pullPolicy" => _openapi_value.pullpolicy) + _openapi_value.reference isa Absent || push!(_openapi_output, "reference" => _openapi_value.reference) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ISCSIVolumeSource + chapauthdiscovery::Union{Absent,Bool,Nothing} = ABSENT + chapauthsession::Union{Absent,Bool,Nothing} = ABSENT + fstype::Union{Absent,Nothing,String} = ABSENT + initiatorname::Union{Absent,Nothing,String} = ABSENT + iqn::String + iscsiinterface::Union{Absent,Nothing,String} = ABSENT + lun::Int32 + portals::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + targetportal::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, value) = _decode(IoK8sApiCoreV1ISCSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ISCSIVolumeSource") + _openapi_field_chapauthdiscovery = haskey(_openapi_object, "chapAuthDiscovery") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthDiscovery"], _openapi_validate) : ABSENT + _openapi_field_chapauthsession = haskey(_openapi_object, "chapAuthSession") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthSession"], _openapi_validate) : ABSENT + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_initiatorname = haskey(_openapi_object, "initiatorName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["initiatorName"], _openapi_validate) : ABSENT + _openapi_field_iqn = _decode(String, _required(_openapi_object, "iqn", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_iscsiinterface = haskey(_openapi_object, "iscsiInterface") ? _decode(Union{Absent,Nothing,String}, _openapi_object["iscsiInterface"], _openapi_validate) : ABSENT + _openapi_field_lun = _decode(Int32, _required(_openapi_object, "lun", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_portals = haskey(_openapi_object, "portals") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["portals"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_targetportal = _decode(String, _required(_openapi_object, "targetPortal", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("chapAuthDiscovery","chapAuthSession","fsType","initiatorName","iqn","iscsiInterface","lun","portals","readOnly","secretRef","targetPortal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ISCSIVolumeSource(; chapauthdiscovery = _openapi_field_chapauthdiscovery, chapauthsession = _openapi_field_chapauthsession, fstype = _openapi_field_fstype, initiatorname = _openapi_field_initiatorname, iqn = _openapi_field_iqn, iscsiinterface = _openapi_field_iscsiinterface, lun = _openapi_field_lun, portals = _openapi_field_portals, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, targetportal = _openapi_field_targetportal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.chapauthdiscovery isa Absent || (_openapi_output["chapAuthDiscovery"] = _encode(_openapi_value.chapauthdiscovery)) + _openapi_value.chapauthsession isa Absent || (_openapi_output["chapAuthSession"] = _encode(_openapi_value.chapauthsession)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.initiatorname isa Absent || (_openapi_output["initiatorName"] = _encode(_openapi_value.initiatorname)) + _openapi_value.iqn isa Absent || (_openapi_output["iqn"] = _encode(_openapi_value.iqn)) + _openapi_value.iscsiinterface isa Absent || (_openapi_output["iscsiInterface"] = _encode(_openapi_value.iscsiinterface)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.portals isa Absent || (_openapi_output["portals"] = _encode(_openapi_value.portals)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.targetportal isa Absent || (_openapi_output["targetPortal"] = _encode(_openapi_value.targetportal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.chapauthdiscovery isa Absent || push!(_openapi_output, "chapAuthDiscovery" => _openapi_value.chapauthdiscovery) + _openapi_value.chapauthsession isa Absent || push!(_openapi_output, "chapAuthSession" => _openapi_value.chapauthsession) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.initiatorname isa Absent || push!(_openapi_output, "initiatorName" => _openapi_value.initiatorname) + _openapi_value.iqn isa Absent || push!(_openapi_output, "iqn" => _openapi_value.iqn) + _openapi_value.iscsiinterface isa Absent || push!(_openapi_output, "iscsiInterface" => _openapi_value.iscsiinterface) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.portals isa Absent || push!(_openapi_output, "portals" => _openapi_value.portals) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.targetportal isa Absent || push!(_openapi_output, "targetPortal" => _openapi_value.targetportal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NFSVolumeSource + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + server::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, value) = _decode(IoK8sApiCoreV1NFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NFSVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_server = _decode(String, _required(_openapi_object, "server", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","readOnly","server") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NFSVolumeSource(; path = _openapi_field_path, readonly = _openapi_field_readonly, server = _openapi_field_server, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.server isa Absent || (_openapi_output["server"] = _encode(_openapi_value.server)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.server isa Absent || push!(_openapi_output, "server" => _openapi_value.server) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimVolumeSource + claimname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource") + _openapi_field_claimname = _decode(String, _required(_openapi_object, "claimName", "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claimName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimVolumeSource(; claimname = _openapi_field_claimname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claimname isa Absent || (_openapi_output["claimName"] = _encode(_openapi_value.claimname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.claimname isa Absent || push!(_openapi_output, "claimName" => _openapi_value.claimname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PhotonPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + pdid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_pdid = _decode(String, _required(_openapi_object, "pdID", "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","pdID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, pdid = _openapi_field_pdid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.pdid isa Absent || (_openapi_output["pdID"] = _encode(_openapi_value.pdid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.pdid isa Absent || push!(_openapi_output, "pdID" => _openapi_value.pdid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PortworxVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, value) = _decode(IoK8sApiCoreV1PortworxVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PortworxVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1PortworxVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PortworxVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ClusterTrustBundleProjection + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + signername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, value) = _decode(IoK8sApiCoreV1ClusterTrustBundleProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ClusterTrustBundleProjection") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ClusterTrustBundleProjection"), _openapi_validate) + _openapi_field_signername = haskey(_openapi_object, "signerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["signerName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","name","optional","path","signerName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ClusterTrustBundleProjection(; labelselector = _openapi_field_labelselector, name = _openapi_field_name, optional = _openapi_field_optional, path = _openapi_field_path, signername = _openapi_field_signername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_output, "encoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, value) = _decode(IoK8sApiCoreV1ConfigMapProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, value) = _decode(IoK8sApiCoreV1DownwardAPIProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIProjection(; items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjectionUserAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, value) = _decode(IoK8sApiCoreV1PodCertificateProjectionUserAnnotations, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjectionUserAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjectionUserAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjection + certificatechainpath::Union{Absent,Nothing,String} = ABSENT + credentialbundlepath::Union{Absent,Nothing,String} = ABSENT + keypath::Union{Absent,Nothing,String} = ABSENT + keytype::String + maxexpirationseconds::Union{Absent,Int32,Nothing} = ABSENT + signername::String + userannotations::Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, value) = _decode(IoK8sApiCoreV1PodCertificateProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjection") + _openapi_field_certificatechainpath = haskey(_openapi_object, "certificateChainPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["certificateChainPath"], _openapi_validate) : ABSENT + _openapi_field_credentialbundlepath = haskey(_openapi_object, "credentialBundlePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["credentialBundlePath"], _openapi_validate) : ABSENT + _openapi_field_keypath = haskey(_openapi_object, "keyPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyPath"], _openapi_validate) : ABSENT + _openapi_field_keytype = _decode(String, _required(_openapi_object, "keyType", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_maxexpirationseconds = haskey(_openapi_object, "maxExpirationSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["maxExpirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_signername = _decode(String, _required(_openapi_object, "signerName", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_userannotations = haskey(_openapi_object, "userAnnotations") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing}, _openapi_object["userAnnotations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("certificateChainPath","credentialBundlePath","keyPath","keyType","maxExpirationSeconds","signerName","userAnnotations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjection(; certificatechainpath = _openapi_field_certificatechainpath, credentialbundlepath = _openapi_field_credentialbundlepath, keypath = _openapi_field_keypath, keytype = _openapi_field_keytype, maxexpirationseconds = _openapi_field_maxexpirationseconds, signername = _openapi_field_signername, userannotations = _openapi_field_userannotations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.certificatechainpath isa Absent || (_openapi_output["certificateChainPath"] = _encode(_openapi_value.certificatechainpath)) + _openapi_value.credentialbundlepath isa Absent || (_openapi_output["credentialBundlePath"] = _encode(_openapi_value.credentialbundlepath)) + _openapi_value.keypath isa Absent || (_openapi_output["keyPath"] = _encode(_openapi_value.keypath)) + _openapi_value.keytype isa Absent || (_openapi_output["keyType"] = _encode(_openapi_value.keytype)) + _openapi_value.maxexpirationseconds isa Absent || (_openapi_output["maxExpirationSeconds"] = _encode(_openapi_value.maxexpirationseconds)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + _openapi_value.userannotations isa Absent || (_openapi_output["userAnnotations"] = _encode(_openapi_value.userannotations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.certificatechainpath isa Absent || push!(_openapi_output, "certificateChainPath" => _openapi_value.certificatechainpath) + _openapi_value.credentialbundlepath isa Absent || push!(_openapi_output, "credentialBundlePath" => _openapi_value.credentialbundlepath) + _openapi_value.keypath isa Absent || push!(_openapi_output, "keyPath" => _openapi_value.keypath) + _openapi_value.keytype isa Absent || push!(_openapi_output, "keyType" => _openapi_value.keytype) + _openapi_value.maxexpirationseconds isa Absent || push!(_openapi_output, "maxExpirationSeconds" => _openapi_value.maxexpirationseconds) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + _openapi_value.userannotations isa Absent || push!(_openapi_output, "userAnnotations" => _openapi_value.userannotations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretProjection}, value) = _decode(IoK8sApiCoreV1SecretProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_raw, "decoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_output, "encoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceAccountTokenProjection + audience::Union{Absent,Nothing,String} = ABSENT + expirationseconds::Union{Absent,Int64,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, value) = _decode(IoK8sApiCoreV1ServiceAccountTokenProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceAccountTokenProjection") + _openapi_field_audience = haskey(_openapi_object, "audience") ? _decode(Union{Absent,Nothing,String}, _openapi_object["audience"], _openapi_validate) : ABSENT + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ServiceAccountTokenProjection"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("audience","expirationSeconds","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceAccountTokenProjection(; audience = _openapi_field_audience, expirationseconds = _openapi_field_expirationseconds, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.audience isa Absent || (_openapi_output["audience"] = _encode(_openapi_value.audience)) + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_output, "encoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.audience isa Absent || push!(_openapi_output, "audience" => _openapi_value.audience) + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeProjection + clustertrustbundle::Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing} = ABSENT + podcertificate::Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing} = ABSENT + serviceaccounttoken::Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeProjection}, value) = _decode(IoK8sApiCoreV1VolumeProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeProjection") + _openapi_field_clustertrustbundle = haskey(_openapi_object, "clusterTrustBundle") ? _decode(Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing}, _openapi_object["clusterTrustBundle"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_podcertificate = haskey(_openapi_object, "podCertificate") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing}, _openapi_object["podCertificate"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_serviceaccounttoken = haskey(_openapi_object, "serviceAccountToken") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing}, _openapi_object["serviceAccountToken"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clusterTrustBundle","configMap","downwardAPI","podCertificate","secret","serviceAccountToken") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeProjection(; clustertrustbundle = _openapi_field_clustertrustbundle, configmap = _openapi_field_configmap, downwardapi = _openapi_field_downwardapi, podcertificate = _openapi_field_podcertificate, secret = _openapi_field_secret, serviceaccounttoken = _openapi_field_serviceaccounttoken, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clustertrustbundle isa Absent || (_openapi_output["clusterTrustBundle"] = _encode(_openapi_value.clustertrustbundle)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.podcertificate isa Absent || (_openapi_output["podCertificate"] = _encode(_openapi_value.podcertificate)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.serviceaccounttoken isa Absent || (_openapi_output["serviceAccountToken"] = _encode(_openapi_value.serviceaccounttoken)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_output, "encoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.clustertrustbundle isa Absent || push!(_openapi_output, "clusterTrustBundle" => _openapi_value.clustertrustbundle) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.podcertificate isa Absent || push!(_openapi_output, "podCertificate" => _openapi_value.podcertificate) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.serviceaccounttoken isa Absent || push!(_openapi_output, "serviceAccountToken" => _openapi_value.serviceaccounttoken) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ProjectedVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + sources::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, value) = _decode(IoK8sApiCoreV1ProjectedVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ProjectedVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_sources = haskey(_openapi_object, "sources") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}}, _openapi_object["sources"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","sources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ProjectedVolumeSource(; defaultmode = _openapi_field_defaultmode, sources = _openapi_field_sources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.sources isa Absent || (_openapi_output["sources"] = _encode(_openapi_value.sources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.sources isa Absent || push!(_openapi_output, "sources" => _openapi_value.sources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1QuobyteVolumeSource + group::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + registry::String + tenant::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + volume::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, value) = _decode(IoK8sApiCoreV1QuobyteVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1QuobyteVolumeSource") + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_registry = _decode(String, _required(_openapi_object, "registry", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_field_tenant = haskey(_openapi_object, "tenant") ? _decode(Union{Absent,Nothing,String}, _openapi_object["tenant"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_field_volume = _decode(String, _required(_openapi_object, "volume", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("group","readOnly","registry","tenant","user","volume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1QuobyteVolumeSource(; group = _openapi_field_group, readonly = _openapi_field_readonly, registry = _openapi_field_registry, tenant = _openapi_field_tenant, user = _openapi_field_user, volume = _openapi_field_volume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.registry isa Absent || (_openapi_output["registry"] = _encode(_openapi_value.registry)) + _openapi_value.tenant isa Absent || (_openapi_output["tenant"] = _encode(_openapi_value.tenant)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + _openapi_value.volume isa Absent || (_openapi_output["volume"] = _encode(_openapi_value.volume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.registry isa Absent || push!(_openapi_output, "registry" => _openapi_value.registry) + _openapi_value.tenant isa Absent || push!(_openapi_output, "tenant" => _openapi_value.tenant) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + _openapi_value.volume isa Absent || push!(_openapi_output, "volume" => _openapi_value.volume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1RBDVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + image::String + keyring::Union{Absent,Nothing,String} = ABSENT + monitors::Union{Nothing,Vector{String}} + pool::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, value) = _decode(IoK8sApiCoreV1RBDVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1RBDVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_keyring = haskey(_openapi_object, "keyring") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyring"], _openapi_validate) : ABSENT + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_pool = haskey(_openapi_object, "pool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pool"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","image","keyring","monitors","pool","readOnly","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1RBDVolumeSource(; fstype = _openapi_field_fstype, image = _openapi_field_image, keyring = _openapi_field_keyring, monitors = _openapi_field_monitors, pool = _openapi_field_pool, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.keyring isa Absent || (_openapi_output["keyring"] = _encode(_openapi_value.keyring)) + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.pool isa Absent || (_openapi_output["pool"] = _encode(_openapi_value.pool)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.keyring isa Absent || push!(_openapi_output, "keyring" => _openapi_value.keyring) + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.pool isa Absent || push!(_openapi_output, "pool" => _openapi_value.pool) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScaleIOVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + gateway::String + protectiondomain::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::IoK8sApiCoreV1LocalObjectReference + sslenabled::Union{Absent,Bool,Nothing} = ABSENT + storagemode::Union{Absent,Nothing,String} = ABSENT + storagepool::Union{Absent,Nothing,String} = ABSENT + system::String + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, value) = _decode(IoK8sApiCoreV1ScaleIOVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScaleIOVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_gateway = _decode(String, _required(_openapi_object, "gateway", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_protectiondomain = haskey(_openapi_object, "protectionDomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protectionDomain"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = _decode(IoK8sApiCoreV1LocalObjectReference, _required(_openapi_object, "secretRef", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_sslenabled = haskey(_openapi_object, "sslEnabled") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["sslEnabled"], _openapi_validate) : ABSENT + _openapi_field_storagemode = haskey(_openapi_object, "storageMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageMode"], _openapi_validate) : ABSENT + _openapi_field_storagepool = haskey(_openapi_object, "storagePool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePool"], _openapi_validate) : ABSENT + _openapi_field_system = _decode(String, _required(_openapi_object, "system", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","gateway","protectionDomain","readOnly","secretRef","sslEnabled","storageMode","storagePool","system","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScaleIOVolumeSource(; fstype = _openapi_field_fstype, gateway = _openapi_field_gateway, protectiondomain = _openapi_field_protectiondomain, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, sslenabled = _openapi_field_sslenabled, storagemode = _openapi_field_storagemode, storagepool = _openapi_field_storagepool, system = _openapi_field_system, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.gateway isa Absent || (_openapi_output["gateway"] = _encode(_openapi_value.gateway)) + _openapi_value.protectiondomain isa Absent || (_openapi_output["protectionDomain"] = _encode(_openapi_value.protectiondomain)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.sslenabled isa Absent || (_openapi_output["sslEnabled"] = _encode(_openapi_value.sslenabled)) + _openapi_value.storagemode isa Absent || (_openapi_output["storageMode"] = _encode(_openapi_value.storagemode)) + _openapi_value.storagepool isa Absent || (_openapi_output["storagePool"] = _encode(_openapi_value.storagepool)) + _openapi_value.system isa Absent || (_openapi_output["system"] = _encode(_openapi_value.system)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.gateway isa Absent || push!(_openapi_output, "gateway" => _openapi_value.gateway) + _openapi_value.protectiondomain isa Absent || push!(_openapi_output, "protectionDomain" => _openapi_value.protectiondomain) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.sslenabled isa Absent || push!(_openapi_output, "sslEnabled" => _openapi_value.sslenabled) + _openapi_value.storagemode isa Absent || push!(_openapi_output, "storageMode" => _openapi_value.storagemode) + _openapi_value.storagepool isa Absent || push!(_openapi_output, "storagePool" => _openapi_value.storagepool) + _openapi_value.system isa Absent || push!(_openapi_output, "system" => _openapi_value.system) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + secretname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, value) = _decode(IoK8sApiCoreV1SecretVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_secretname = haskey(_openapi_object, "secretName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","optional","secretName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, optional = _openapi_field_optional, secretname = _openapi_field_secretname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1StorageOSVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + volumenamespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, value) = _decode(IoK8sApiCoreV1StorageOSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1StorageOSVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_field_volumenamespace = haskey(_openapi_object, "volumeNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeNamespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeName","volumeNamespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1StorageOSVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumename = _openapi_field_volumename, volumenamespace = _openapi_field_volumenamespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + _openapi_value.volumenamespace isa Absent || (_openapi_output["volumeNamespace"] = _encode(_openapi_value.volumenamespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + _openapi_value.volumenamespace isa Absent || push!(_openapi_output, "volumeNamespace" => _openapi_value.volumenamespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VsphereVirtualDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + storagepolicyid::Union{Absent,Nothing,String} = ABSENT + storagepolicyname::Union{Absent,Nothing,String} = ABSENT + volumepath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyid = haskey(_openapi_object, "storagePolicyID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyID"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyname = haskey(_openapi_object, "storagePolicyName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyName"], _openapi_validate) : ABSENT + _openapi_field_volumepath = _decode(String, _required(_openapi_object, "volumePath", "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","storagePolicyID","storagePolicyName","volumePath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(; fstype = _openapi_field_fstype, storagepolicyid = _openapi_field_storagepolicyid, storagepolicyname = _openapi_field_storagepolicyname, volumepath = _openapi_field_volumepath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.storagepolicyid isa Absent || (_openapi_output["storagePolicyID"] = _encode(_openapi_value.storagepolicyid)) + _openapi_value.storagepolicyname isa Absent || (_openapi_output["storagePolicyName"] = _encode(_openapi_value.storagepolicyname)) + _openapi_value.volumepath isa Absent || (_openapi_output["volumePath"] = _encode(_openapi_value.volumepath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.storagepolicyid isa Absent || push!(_openapi_output, "storagePolicyID" => _openapi_value.storagepolicyid) + _openapi_value.storagepolicyname isa Absent || push!(_openapi_output, "storagePolicyName" => _openapi_value.storagepolicyname) + _openapi_value.volumepath isa Absent || push!(_openapi_output, "volumePath" => _openapi_value.volumepath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Volume + awselasticblockstore::Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing} = ABSENT + azuredisk::Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing} = ABSENT + azurefile::Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing} = ABSENT + cephfs::Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing} = ABSENT + cinder::Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing} = ABSENT + csi::Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing} = ABSENT + emptydir::Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing} = ABSENT + ephemeral::Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing} = ABSENT + fc::Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing} = ABSENT + flexvolume::Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing} = ABSENT + flocker::Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing} = ABSENT + gcepersistentdisk::Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing} = ABSENT + gitrepo::Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing} = ABSENT + glusterfs::Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing} = ABSENT + hostpath::Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing} = ABSENT + image::Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing} = ABSENT + iscsi::Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing} = ABSENT + name::String + nfs::Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing} = ABSENT + persistentvolumeclaim::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing} = ABSENT + photonpersistentdisk::Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing} = ABSENT + portworxvolume::Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing} = ABSENT + projected::Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing} = ABSENT + quobyte::Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing} = ABSENT + rbd::Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing} = ABSENT + scaleio::Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing} = ABSENT + storageos::Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing} = ABSENT + vspherevolume::Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Volume}, value) = _decode(IoK8sApiCoreV1Volume, value, true) +function _decode(::Type{IoK8sApiCoreV1Volume}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_raw, "decoding IoK8sApiCoreV1Volume"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Volume") + _openapi_field_awselasticblockstore = haskey(_openapi_object, "awsElasticBlockStore") ? _decode(Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing}, _openapi_object["awsElasticBlockStore"], _openapi_validate) : ABSENT + _openapi_field_azuredisk = haskey(_openapi_object, "azureDisk") ? _decode(Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing}, _openapi_object["azureDisk"], _openapi_validate) : ABSENT + _openapi_field_azurefile = haskey(_openapi_object, "azureFile") ? _decode(Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing}, _openapi_object["azureFile"], _openapi_validate) : ABSENT + _openapi_field_cephfs = haskey(_openapi_object, "cephfs") ? _decode(Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing}, _openapi_object["cephfs"], _openapi_validate) : ABSENT + _openapi_field_cinder = haskey(_openapi_object, "cinder") ? _decode(Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing}, _openapi_object["cinder"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_csi = haskey(_openapi_object, "csi") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing}, _openapi_object["csi"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_emptydir = haskey(_openapi_object, "emptyDir") ? _decode(Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing}, _openapi_object["emptyDir"], _openapi_validate) : ABSENT + _openapi_field_ephemeral = haskey(_openapi_object, "ephemeral") ? _decode(Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing}, _openapi_object["ephemeral"], _openapi_validate) : ABSENT + _openapi_field_fc = haskey(_openapi_object, "fc") ? _decode(Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing}, _openapi_object["fc"], _openapi_validate) : ABSENT + _openapi_field_flexvolume = haskey(_openapi_object, "flexVolume") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing}, _openapi_object["flexVolume"], _openapi_validate) : ABSENT + _openapi_field_flocker = haskey(_openapi_object, "flocker") ? _decode(Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing}, _openapi_object["flocker"], _openapi_validate) : ABSENT + _openapi_field_gcepersistentdisk = haskey(_openapi_object, "gcePersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing}, _openapi_object["gcePersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_gitrepo = haskey(_openapi_object, "gitRepo") ? _decode(Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing}, _openapi_object["gitRepo"], _openapi_validate) : ABSENT + _openapi_field_glusterfs = haskey(_openapi_object, "glusterfs") ? _decode(Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing}, _openapi_object["glusterfs"], _openapi_validate) : ABSENT + _openapi_field_hostpath = haskey(_openapi_object, "hostPath") ? _decode(Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing}, _openapi_object["hostPath"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_iscsi = haskey(_openapi_object, "iscsi") ? _decode(Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing}, _openapi_object["iscsi"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Volume"), _openapi_validate) + _openapi_field_nfs = haskey(_openapi_object, "nfs") ? _decode(Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing}, _openapi_object["nfs"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumeclaim = haskey(_openapi_object, "persistentVolumeClaim") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing}, _openapi_object["persistentVolumeClaim"], _openapi_validate) : ABSENT + _openapi_field_photonpersistentdisk = haskey(_openapi_object, "photonPersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing}, _openapi_object["photonPersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_portworxvolume = haskey(_openapi_object, "portworxVolume") ? _decode(Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing}, _openapi_object["portworxVolume"], _openapi_validate) : ABSENT + _openapi_field_projected = haskey(_openapi_object, "projected") ? _decode(Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing}, _openapi_object["projected"], _openapi_validate) : ABSENT + _openapi_field_quobyte = haskey(_openapi_object, "quobyte") ? _decode(Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing}, _openapi_object["quobyte"], _openapi_validate) : ABSENT + _openapi_field_rbd = haskey(_openapi_object, "rbd") ? _decode(Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing}, _openapi_object["rbd"], _openapi_validate) : ABSENT + _openapi_field_scaleio = haskey(_openapi_object, "scaleIO") ? _decode(Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing}, _openapi_object["scaleIO"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_storageos = haskey(_openapi_object, "storageos") ? _decode(Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing}, _openapi_object["storageos"], _openapi_validate) : ABSENT + _openapi_field_vspherevolume = haskey(_openapi_object, "vsphereVolume") ? _decode(Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing}, _openapi_object["vsphereVolume"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("awsElasticBlockStore","azureDisk","azureFile","cephfs","cinder","configMap","csi","downwardAPI","emptyDir","ephemeral","fc","flexVolume","flocker","gcePersistentDisk","gitRepo","glusterfs","hostPath","image","iscsi","name","nfs","persistentVolumeClaim","photonPersistentDisk","portworxVolume","projected","quobyte","rbd","scaleIO","secret","storageos","vsphereVolume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Volume(; awselasticblockstore = _openapi_field_awselasticblockstore, azuredisk = _openapi_field_azuredisk, azurefile = _openapi_field_azurefile, cephfs = _openapi_field_cephfs, cinder = _openapi_field_cinder, configmap = _openapi_field_configmap, csi = _openapi_field_csi, downwardapi = _openapi_field_downwardapi, emptydir = _openapi_field_emptydir, ephemeral = _openapi_field_ephemeral, fc = _openapi_field_fc, flexvolume = _openapi_field_flexvolume, flocker = _openapi_field_flocker, gcepersistentdisk = _openapi_field_gcepersistentdisk, gitrepo = _openapi_field_gitrepo, glusterfs = _openapi_field_glusterfs, hostpath = _openapi_field_hostpath, image = _openapi_field_image, iscsi = _openapi_field_iscsi, name = _openapi_field_name, nfs = _openapi_field_nfs, persistentvolumeclaim = _openapi_field_persistentvolumeclaim, photonpersistentdisk = _openapi_field_photonpersistentdisk, portworxvolume = _openapi_field_portworxvolume, projected = _openapi_field_projected, quobyte = _openapi_field_quobyte, rbd = _openapi_field_rbd, scaleio = _openapi_field_scaleio, secret = _openapi_field_secret, storageos = _openapi_field_storageos, vspherevolume = _openapi_field_vspherevolume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.awselasticblockstore isa Absent || (_openapi_output["awsElasticBlockStore"] = _encode(_openapi_value.awselasticblockstore)) + _openapi_value.azuredisk isa Absent || (_openapi_output["azureDisk"] = _encode(_openapi_value.azuredisk)) + _openapi_value.azurefile isa Absent || (_openapi_output["azureFile"] = _encode(_openapi_value.azurefile)) + _openapi_value.cephfs isa Absent || (_openapi_output["cephfs"] = _encode(_openapi_value.cephfs)) + _openapi_value.cinder isa Absent || (_openapi_output["cinder"] = _encode(_openapi_value.cinder)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.csi isa Absent || (_openapi_output["csi"] = _encode(_openapi_value.csi)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.emptydir isa Absent || (_openapi_output["emptyDir"] = _encode(_openapi_value.emptydir)) + _openapi_value.ephemeral isa Absent || (_openapi_output["ephemeral"] = _encode(_openapi_value.ephemeral)) + _openapi_value.fc isa Absent || (_openapi_output["fc"] = _encode(_openapi_value.fc)) + _openapi_value.flexvolume isa Absent || (_openapi_output["flexVolume"] = _encode(_openapi_value.flexvolume)) + _openapi_value.flocker isa Absent || (_openapi_output["flocker"] = _encode(_openapi_value.flocker)) + _openapi_value.gcepersistentdisk isa Absent || (_openapi_output["gcePersistentDisk"] = _encode(_openapi_value.gcepersistentdisk)) + _openapi_value.gitrepo isa Absent || (_openapi_output["gitRepo"] = _encode(_openapi_value.gitrepo)) + _openapi_value.glusterfs isa Absent || (_openapi_output["glusterfs"] = _encode(_openapi_value.glusterfs)) + _openapi_value.hostpath isa Absent || (_openapi_output["hostPath"] = _encode(_openapi_value.hostpath)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.iscsi isa Absent || (_openapi_output["iscsi"] = _encode(_openapi_value.iscsi)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.nfs isa Absent || (_openapi_output["nfs"] = _encode(_openapi_value.nfs)) + _openapi_value.persistentvolumeclaim isa Absent || (_openapi_output["persistentVolumeClaim"] = _encode(_openapi_value.persistentvolumeclaim)) + _openapi_value.photonpersistentdisk isa Absent || (_openapi_output["photonPersistentDisk"] = _encode(_openapi_value.photonpersistentdisk)) + _openapi_value.portworxvolume isa Absent || (_openapi_output["portworxVolume"] = _encode(_openapi_value.portworxvolume)) + _openapi_value.projected isa Absent || (_openapi_output["projected"] = _encode(_openapi_value.projected)) + _openapi_value.quobyte isa Absent || (_openapi_output["quobyte"] = _encode(_openapi_value.quobyte)) + _openapi_value.rbd isa Absent || (_openapi_output["rbd"] = _encode(_openapi_value.rbd)) + _openapi_value.scaleio isa Absent || (_openapi_output["scaleIO"] = _encode(_openapi_value.scaleio)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.storageos isa Absent || (_openapi_output["storageos"] = _encode(_openapi_value.storageos)) + _openapi_value.vspherevolume isa Absent || (_openapi_output["vsphereVolume"] = _encode(_openapi_value.vspherevolume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_output, "encoding IoK8sApiCoreV1Volume"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = Pair{String,Any}[] + _openapi_value.awselasticblockstore isa Absent || push!(_openapi_output, "awsElasticBlockStore" => _openapi_value.awselasticblockstore) + _openapi_value.azuredisk isa Absent || push!(_openapi_output, "azureDisk" => _openapi_value.azuredisk) + _openapi_value.azurefile isa Absent || push!(_openapi_output, "azureFile" => _openapi_value.azurefile) + _openapi_value.cephfs isa Absent || push!(_openapi_output, "cephfs" => _openapi_value.cephfs) + _openapi_value.cinder isa Absent || push!(_openapi_output, "cinder" => _openapi_value.cinder) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.csi isa Absent || push!(_openapi_output, "csi" => _openapi_value.csi) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.emptydir isa Absent || push!(_openapi_output, "emptyDir" => _openapi_value.emptydir) + _openapi_value.ephemeral isa Absent || push!(_openapi_output, "ephemeral" => _openapi_value.ephemeral) + _openapi_value.fc isa Absent || push!(_openapi_output, "fc" => _openapi_value.fc) + _openapi_value.flexvolume isa Absent || push!(_openapi_output, "flexVolume" => _openapi_value.flexvolume) + _openapi_value.flocker isa Absent || push!(_openapi_output, "flocker" => _openapi_value.flocker) + _openapi_value.gcepersistentdisk isa Absent || push!(_openapi_output, "gcePersistentDisk" => _openapi_value.gcepersistentdisk) + _openapi_value.gitrepo isa Absent || push!(_openapi_output, "gitRepo" => _openapi_value.gitrepo) + _openapi_value.glusterfs isa Absent || push!(_openapi_output, "glusterfs" => _openapi_value.glusterfs) + _openapi_value.hostpath isa Absent || push!(_openapi_output, "hostPath" => _openapi_value.hostpath) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.iscsi isa Absent || push!(_openapi_output, "iscsi" => _openapi_value.iscsi) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.nfs isa Absent || push!(_openapi_output, "nfs" => _openapi_value.nfs) + _openapi_value.persistentvolumeclaim isa Absent || push!(_openapi_output, "persistentVolumeClaim" => _openapi_value.persistentvolumeclaim) + _openapi_value.photonpersistentdisk isa Absent || push!(_openapi_output, "photonPersistentDisk" => _openapi_value.photonpersistentdisk) + _openapi_value.portworxvolume isa Absent || push!(_openapi_output, "portworxVolume" => _openapi_value.portworxvolume) + _openapi_value.projected isa Absent || push!(_openapi_output, "projected" => _openapi_value.projected) + _openapi_value.quobyte isa Absent || push!(_openapi_output, "quobyte" => _openapi_value.quobyte) + _openapi_value.rbd isa Absent || push!(_openapi_output, "rbd" => _openapi_value.rbd) + _openapi_value.scaleio isa Absent || push!(_openapi_output, "scaleIO" => _openapi_value.scaleio) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.storageos isa Absent || push!(_openapi_output, "storageos" => _openapi_value.storageos) + _openapi_value.vspherevolume isa Absent || push!(_openapi_output, "vsphereVolume" => _openapi_value.vspherevolume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WorkloadReference + name::String + podgroup::String + podgroupreplicakey::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WorkloadReference}, value) = _decode(IoK8sApiCoreV1WorkloadReference, value, true) +function _decode(::Type{IoK8sApiCoreV1WorkloadReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_raw, "decoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WorkloadReference") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroup = _decode(String, _required(_openapi_object, "podGroup", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroupreplicakey = haskey(_openapi_object, "podGroupReplicaKey") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podGroupReplicaKey"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","podGroup","podGroupReplicaKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WorkloadReference(; name = _openapi_field_name, podgroup = _openapi_field_podgroup, podgroupreplicakey = _openapi_field_podgroupreplicakey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.podgroup isa Absent || (_openapi_output["podGroup"] = _encode(_openapi_value.podgroup)) + _openapi_value.podgroupreplicakey isa Absent || (_openapi_output["podGroupReplicaKey"] = _encode(_openapi_value.podgroupreplicakey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_output, "encoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.podgroup isa Absent || push!(_openapi_output, "podGroup" => _openapi_value.podgroup) + _openapi_value.podgroupreplicakey isa Absent || push!(_openapi_output, "podGroupReplicaKey" => _openapi_value.podgroupreplicakey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpec + activedeadlineseconds::Union{Absent,Int64,Nothing} = ABSENT + affinity::Union{Absent,IoK8sApiCoreV1Affinity,Nothing} = ABSENT + automountserviceaccounttoken::Union{Absent,Bool,Nothing} = ABSENT + containers::Union{Nothing,Vector{IoK8sApiCoreV1Container}} + dnsconfig::Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing} = ABSENT + dnspolicy::Union{Absent,Nothing,String} = ABSENT + enableservicelinks::Union{Absent,Bool,Nothing} = ABSENT + ephemeralcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}} = ABSENT + hostaliases::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}} = ABSENT + hostipc::Union{Absent,Bool,Nothing} = ABSENT + hostnetwork::Union{Absent,Bool,Nothing} = ABSENT + hostpid::Union{Absent,Bool,Nothing} = ABSENT + hostusers::Union{Absent,Bool,Nothing} = ABSENT + hostname::Union{Absent,Nothing,String} = ABSENT + hostnameoverride::Union{Absent,Nothing,String} = ABSENT + imagepullsecrets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}} = ABSENT + initcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}} = ABSENT + nodename::Union{Absent,Nothing,String} = ABSENT + nodeselector::Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing} = ABSENT + os::Union{Absent,IoK8sApiCoreV1PodOS,Nothing} = ABSENT + overhead::Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing} = ABSENT + preemptionpolicy::Union{Absent,Nothing,String} = ABSENT + priority::Union{Absent,Int32,Nothing} = ABSENT + priorityclassname::Union{Absent,Nothing,String} = ABSENT + readinessgates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}} = ABSENT + resourceclaims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + runtimeclassname::Union{Absent,Nothing,String} = ABSENT + schedulername::Union{Absent,Nothing,String} = ABSENT + schedulinggates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing} = ABSENT + serviceaccount::Union{Absent,Nothing,String} = ABSENT + serviceaccountname::Union{Absent,Nothing,String} = ABSENT + sethostnameasfqdn::Union{Absent,Bool,Nothing} = ABSENT + shareprocessnamespace::Union{Absent,Bool,Nothing} = ABSENT + subdomain::Union{Absent,Nothing,String} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + tolerations::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}} = ABSENT + topologyspreadconstraints::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}} = ABSENT + volumes::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}} = ABSENT + workloadref::Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSpec}, value) = _decode(IoK8sApiCoreV1PodSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpec") + _openapi_field_activedeadlineseconds = haskey(_openapi_object, "activeDeadlineSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["activeDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_affinity = haskey(_openapi_object, "affinity") ? _decode(Union{Absent,IoK8sApiCoreV1Affinity,Nothing}, _openapi_object["affinity"], _openapi_validate) : ABSENT + _openapi_field_automountserviceaccounttoken = haskey(_openapi_object, "automountServiceAccountToken") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["automountServiceAccountToken"], _openapi_validate) : ABSENT + _openapi_field_containers = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Container}}, _required(_openapi_object, "containers", "IoK8sApiCoreV1PodSpec"), _openapi_validate) + _openapi_field_dnsconfig = haskey(_openapi_object, "dnsConfig") ? _decode(Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing}, _openapi_object["dnsConfig"], _openapi_validate) : ABSENT + _openapi_field_dnspolicy = haskey(_openapi_object, "dnsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["dnsPolicy"], _openapi_validate) : ABSENT + _openapi_field_enableservicelinks = haskey(_openapi_object, "enableServiceLinks") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["enableServiceLinks"], _openapi_validate) : ABSENT + _openapi_field_ephemeralcontainers = haskey(_openapi_object, "ephemeralContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}}, _openapi_object["ephemeralContainers"], _openapi_validate) : ABSENT + _openapi_field_hostaliases = haskey(_openapi_object, "hostAliases") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}}, _openapi_object["hostAliases"], _openapi_validate) : ABSENT + _openapi_field_hostipc = haskey(_openapi_object, "hostIPC") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostIPC"], _openapi_validate) : ABSENT + _openapi_field_hostnetwork = haskey(_openapi_object, "hostNetwork") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostNetwork"], _openapi_validate) : ABSENT + _openapi_field_hostpid = haskey(_openapi_object, "hostPID") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostPID"], _openapi_validate) : ABSENT + _openapi_field_hostusers = haskey(_openapi_object, "hostUsers") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostUsers"], _openapi_validate) : ABSENT + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_hostnameoverride = haskey(_openapi_object, "hostnameOverride") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostnameOverride"], _openapi_validate) : ABSENT + _openapi_field_imagepullsecrets = haskey(_openapi_object, "imagePullSecrets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}}, _openapi_object["imagePullSecrets"], _openapi_validate) : ABSENT + _openapi_field_initcontainers = haskey(_openapi_object, "initContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}}, _openapi_object["initContainers"], _openapi_validate) : ABSENT + _openapi_field_nodename = haskey(_openapi_object, "nodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeName"], _openapi_validate) : ABSENT + _openapi_field_nodeselector = haskey(_openapi_object, "nodeSelector") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing}, _openapi_object["nodeSelector"], _openapi_validate) : ABSENT + _openapi_field_os = haskey(_openapi_object, "os") ? _decode(Union{Absent,IoK8sApiCoreV1PodOS,Nothing}, _openapi_object["os"], _openapi_validate) : ABSENT + _openapi_field_overhead = haskey(_openapi_object, "overhead") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing}, _openapi_object["overhead"], _openapi_validate) : ABSENT + _openapi_field_preemptionpolicy = haskey(_openapi_object, "preemptionPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["preemptionPolicy"], _openapi_validate) : ABSENT + _openapi_field_priority = haskey(_openapi_object, "priority") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["priority"], _openapi_validate) : ABSENT + _openapi_field_priorityclassname = haskey(_openapi_object, "priorityClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["priorityClassName"], _openapi_validate) : ABSENT + _openapi_field_readinessgates = haskey(_openapi_object, "readinessGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}}, _openapi_object["readinessGates"], _openapi_validate) : ABSENT + _openapi_field_resourceclaims = haskey(_openapi_object, "resourceClaims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}}, _openapi_object["resourceClaims"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_runtimeclassname = haskey(_openapi_object, "runtimeClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runtimeClassName"], _openapi_validate) : ABSENT + _openapi_field_schedulername = haskey(_openapi_object, "schedulerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["schedulerName"], _openapi_validate) : ABSENT + _openapi_field_schedulinggates = haskey(_openapi_object, "schedulingGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}}, _openapi_object["schedulingGates"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_serviceaccount = haskey(_openapi_object, "serviceAccount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccount"], _openapi_validate) : ABSENT + _openapi_field_serviceaccountname = haskey(_openapi_object, "serviceAccountName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccountName"], _openapi_validate) : ABSENT + _openapi_field_sethostnameasfqdn = haskey(_openapi_object, "setHostnameAsFQDN") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["setHostnameAsFQDN"], _openapi_validate) : ABSENT + _openapi_field_shareprocessnamespace = haskey(_openapi_object, "shareProcessNamespace") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["shareProcessNamespace"], _openapi_validate) : ABSENT + _openapi_field_subdomain = haskey(_openapi_object, "subdomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subdomain"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_tolerations = haskey(_openapi_object, "tolerations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}}, _openapi_object["tolerations"], _openapi_validate) : ABSENT + _openapi_field_topologyspreadconstraints = haskey(_openapi_object, "topologySpreadConstraints") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}}, _openapi_object["topologySpreadConstraints"], _openapi_validate) : ABSENT + _openapi_field_volumes = haskey(_openapi_object, "volumes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}}, _openapi_object["volumes"], _openapi_validate) : ABSENT + _openapi_field_workloadref = haskey(_openapi_object, "workloadRef") ? _decode(Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing}, _openapi_object["workloadRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("activeDeadlineSeconds","affinity","automountServiceAccountToken","containers","dnsConfig","dnsPolicy","enableServiceLinks","ephemeralContainers","hostAliases","hostIPC","hostNetwork","hostPID","hostUsers","hostname","hostnameOverride","imagePullSecrets","initContainers","nodeName","nodeSelector","os","overhead","preemptionPolicy","priority","priorityClassName","readinessGates","resourceClaims","resources","restartPolicy","runtimeClassName","schedulerName","schedulingGates","securityContext","serviceAccount","serviceAccountName","setHostnameAsFQDN","shareProcessNamespace","subdomain","terminationGracePeriodSeconds","tolerations","topologySpreadConstraints","volumes","workloadRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpec(; activedeadlineseconds = _openapi_field_activedeadlineseconds, affinity = _openapi_field_affinity, automountserviceaccounttoken = _openapi_field_automountserviceaccounttoken, containers = _openapi_field_containers, dnsconfig = _openapi_field_dnsconfig, dnspolicy = _openapi_field_dnspolicy, enableservicelinks = _openapi_field_enableservicelinks, ephemeralcontainers = _openapi_field_ephemeralcontainers, hostaliases = _openapi_field_hostaliases, hostipc = _openapi_field_hostipc, hostnetwork = _openapi_field_hostnetwork, hostpid = _openapi_field_hostpid, hostusers = _openapi_field_hostusers, hostname = _openapi_field_hostname, hostnameoverride = _openapi_field_hostnameoverride, imagepullsecrets = _openapi_field_imagepullsecrets, initcontainers = _openapi_field_initcontainers, nodename = _openapi_field_nodename, nodeselector = _openapi_field_nodeselector, os = _openapi_field_os, overhead = _openapi_field_overhead, preemptionpolicy = _openapi_field_preemptionpolicy, priority = _openapi_field_priority, priorityclassname = _openapi_field_priorityclassname, readinessgates = _openapi_field_readinessgates, resourceclaims = _openapi_field_resourceclaims, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, runtimeclassname = _openapi_field_runtimeclassname, schedulername = _openapi_field_schedulername, schedulinggates = _openapi_field_schedulinggates, securitycontext = _openapi_field_securitycontext, serviceaccount = _openapi_field_serviceaccount, serviceaccountname = _openapi_field_serviceaccountname, sethostnameasfqdn = _openapi_field_sethostnameasfqdn, shareprocessnamespace = _openapi_field_shareprocessnamespace, subdomain = _openapi_field_subdomain, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, tolerations = _openapi_field_tolerations, topologyspreadconstraints = _openapi_field_topologyspreadconstraints, volumes = _openapi_field_volumes, workloadref = _openapi_field_workloadref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.activedeadlineseconds isa Absent || (_openapi_output["activeDeadlineSeconds"] = _encode(_openapi_value.activedeadlineseconds)) + _openapi_value.affinity isa Absent || (_openapi_output["affinity"] = _encode(_openapi_value.affinity)) + _openapi_value.automountserviceaccounttoken isa Absent || (_openapi_output["automountServiceAccountToken"] = _encode(_openapi_value.automountserviceaccounttoken)) + _openapi_value.containers isa Absent || (_openapi_output["containers"] = _encode(_openapi_value.containers)) + _openapi_value.dnsconfig isa Absent || (_openapi_output["dnsConfig"] = _encode(_openapi_value.dnsconfig)) + _openapi_value.dnspolicy isa Absent || (_openapi_output["dnsPolicy"] = _encode(_openapi_value.dnspolicy)) + _openapi_value.enableservicelinks isa Absent || (_openapi_output["enableServiceLinks"] = _encode(_openapi_value.enableservicelinks)) + _openapi_value.ephemeralcontainers isa Absent || (_openapi_output["ephemeralContainers"] = _encode(_openapi_value.ephemeralcontainers)) + _openapi_value.hostaliases isa Absent || (_openapi_output["hostAliases"] = _encode(_openapi_value.hostaliases)) + _openapi_value.hostipc isa Absent || (_openapi_output["hostIPC"] = _encode(_openapi_value.hostipc)) + _openapi_value.hostnetwork isa Absent || (_openapi_output["hostNetwork"] = _encode(_openapi_value.hostnetwork)) + _openapi_value.hostpid isa Absent || (_openapi_output["hostPID"] = _encode(_openapi_value.hostpid)) + _openapi_value.hostusers isa Absent || (_openapi_output["hostUsers"] = _encode(_openapi_value.hostusers)) + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.hostnameoverride isa Absent || (_openapi_output["hostnameOverride"] = _encode(_openapi_value.hostnameoverride)) + _openapi_value.imagepullsecrets isa Absent || (_openapi_output["imagePullSecrets"] = _encode(_openapi_value.imagepullsecrets)) + _openapi_value.initcontainers isa Absent || (_openapi_output["initContainers"] = _encode(_openapi_value.initcontainers)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.nodeselector isa Absent || (_openapi_output["nodeSelector"] = _encode(_openapi_value.nodeselector)) + _openapi_value.os isa Absent || (_openapi_output["os"] = _encode(_openapi_value.os)) + _openapi_value.overhead isa Absent || (_openapi_output["overhead"] = _encode(_openapi_value.overhead)) + _openapi_value.preemptionpolicy isa Absent || (_openapi_output["preemptionPolicy"] = _encode(_openapi_value.preemptionpolicy)) + _openapi_value.priority isa Absent || (_openapi_output["priority"] = _encode(_openapi_value.priority)) + _openapi_value.priorityclassname isa Absent || (_openapi_output["priorityClassName"] = _encode(_openapi_value.priorityclassname)) + _openapi_value.readinessgates isa Absent || (_openapi_output["readinessGates"] = _encode(_openapi_value.readinessgates)) + _openapi_value.resourceclaims isa Absent || (_openapi_output["resourceClaims"] = _encode(_openapi_value.resourceclaims)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.runtimeclassname isa Absent || (_openapi_output["runtimeClassName"] = _encode(_openapi_value.runtimeclassname)) + _openapi_value.schedulername isa Absent || (_openapi_output["schedulerName"] = _encode(_openapi_value.schedulername)) + _openapi_value.schedulinggates isa Absent || (_openapi_output["schedulingGates"] = _encode(_openapi_value.schedulinggates)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.serviceaccount isa Absent || (_openapi_output["serviceAccount"] = _encode(_openapi_value.serviceaccount)) + _openapi_value.serviceaccountname isa Absent || (_openapi_output["serviceAccountName"] = _encode(_openapi_value.serviceaccountname)) + _openapi_value.sethostnameasfqdn isa Absent || (_openapi_output["setHostnameAsFQDN"] = _encode(_openapi_value.sethostnameasfqdn)) + _openapi_value.shareprocessnamespace isa Absent || (_openapi_output["shareProcessNamespace"] = _encode(_openapi_value.shareprocessnamespace)) + _openapi_value.subdomain isa Absent || (_openapi_output["subdomain"] = _encode(_openapi_value.subdomain)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.tolerations isa Absent || (_openapi_output["tolerations"] = _encode(_openapi_value.tolerations)) + _openapi_value.topologyspreadconstraints isa Absent || (_openapi_output["topologySpreadConstraints"] = _encode(_openapi_value.topologyspreadconstraints)) + _openapi_value.volumes isa Absent || (_openapi_output["volumes"] = _encode(_openapi_value.volumes)) + _openapi_value.workloadref isa Absent || (_openapi_output["workloadRef"] = _encode(_openapi_value.workloadref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.activedeadlineseconds isa Absent || push!(_openapi_output, "activeDeadlineSeconds" => _openapi_value.activedeadlineseconds) + _openapi_value.affinity isa Absent || push!(_openapi_output, "affinity" => _openapi_value.affinity) + _openapi_value.automountserviceaccounttoken isa Absent || push!(_openapi_output, "automountServiceAccountToken" => _openapi_value.automountserviceaccounttoken) + _openapi_value.containers isa Absent || push!(_openapi_output, "containers" => _openapi_value.containers) + _openapi_value.dnsconfig isa Absent || push!(_openapi_output, "dnsConfig" => _openapi_value.dnsconfig) + _openapi_value.dnspolicy isa Absent || push!(_openapi_output, "dnsPolicy" => _openapi_value.dnspolicy) + _openapi_value.enableservicelinks isa Absent || push!(_openapi_output, "enableServiceLinks" => _openapi_value.enableservicelinks) + _openapi_value.ephemeralcontainers isa Absent || push!(_openapi_output, "ephemeralContainers" => _openapi_value.ephemeralcontainers) + _openapi_value.hostaliases isa Absent || push!(_openapi_output, "hostAliases" => _openapi_value.hostaliases) + _openapi_value.hostipc isa Absent || push!(_openapi_output, "hostIPC" => _openapi_value.hostipc) + _openapi_value.hostnetwork isa Absent || push!(_openapi_output, "hostNetwork" => _openapi_value.hostnetwork) + _openapi_value.hostpid isa Absent || push!(_openapi_output, "hostPID" => _openapi_value.hostpid) + _openapi_value.hostusers isa Absent || push!(_openapi_output, "hostUsers" => _openapi_value.hostusers) + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.hostnameoverride isa Absent || push!(_openapi_output, "hostnameOverride" => _openapi_value.hostnameoverride) + _openapi_value.imagepullsecrets isa Absent || push!(_openapi_output, "imagePullSecrets" => _openapi_value.imagepullsecrets) + _openapi_value.initcontainers isa Absent || push!(_openapi_output, "initContainers" => _openapi_value.initcontainers) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.nodeselector isa Absent || push!(_openapi_output, "nodeSelector" => _openapi_value.nodeselector) + _openapi_value.os isa Absent || push!(_openapi_output, "os" => _openapi_value.os) + _openapi_value.overhead isa Absent || push!(_openapi_output, "overhead" => _openapi_value.overhead) + _openapi_value.preemptionpolicy isa Absent || push!(_openapi_output, "preemptionPolicy" => _openapi_value.preemptionpolicy) + _openapi_value.priority isa Absent || push!(_openapi_output, "priority" => _openapi_value.priority) + _openapi_value.priorityclassname isa Absent || push!(_openapi_output, "priorityClassName" => _openapi_value.priorityclassname) + _openapi_value.readinessgates isa Absent || push!(_openapi_output, "readinessGates" => _openapi_value.readinessgates) + _openapi_value.resourceclaims isa Absent || push!(_openapi_output, "resourceClaims" => _openapi_value.resourceclaims) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.runtimeclassname isa Absent || push!(_openapi_output, "runtimeClassName" => _openapi_value.runtimeclassname) + _openapi_value.schedulername isa Absent || push!(_openapi_output, "schedulerName" => _openapi_value.schedulername) + _openapi_value.schedulinggates isa Absent || push!(_openapi_output, "schedulingGates" => _openapi_value.schedulinggates) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.serviceaccount isa Absent || push!(_openapi_output, "serviceAccount" => _openapi_value.serviceaccount) + _openapi_value.serviceaccountname isa Absent || push!(_openapi_output, "serviceAccountName" => _openapi_value.serviceaccountname) + _openapi_value.sethostnameasfqdn isa Absent || push!(_openapi_output, "setHostnameAsFQDN" => _openapi_value.sethostnameasfqdn) + _openapi_value.shareprocessnamespace isa Absent || push!(_openapi_output, "shareProcessNamespace" => _openapi_value.shareprocessnamespace) + _openapi_value.subdomain isa Absent || push!(_openapi_output, "subdomain" => _openapi_value.subdomain) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.tolerations isa Absent || push!(_openapi_output, "tolerations" => _openapi_value.tolerations) + _openapi_value.topologyspreadconstraints isa Absent || push!(_openapi_output, "topologySpreadConstraints" => _openapi_value.topologyspreadconstraints) + _openapi_value.volumes isa Absent || push!(_openapi_output, "volumes" => _openapi_value.volumes) + _openapi_value.workloadref isa Absent || push!(_openapi_output, "workloadRef" => _openapi_value.workloadref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodTemplateSpec + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PodSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, value) = _decode(IoK8sApiCoreV1PodTemplateSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodTemplateSpec") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodTemplateSpec(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1JobSpec + activedeadlineseconds::Union{Absent,Int64,Nothing} = ABSENT + backofflimit::Union{Absent,Int32,Nothing} = ABSENT + backofflimitperindex::Union{Absent,Int32,Nothing} = ABSENT + completionmode::Union{Absent,Nothing,String} = ABSENT + completions::Union{Absent,Int32,Nothing} = ABSENT + managedby::Union{Absent,Nothing,String} = ABSENT + manualselector::Union{Absent,Bool,Nothing} = ABSENT + maxfailedindexes::Union{Absent,Int32,Nothing} = ABSENT + parallelism::Union{Absent,Int32,Nothing} = ABSENT + podfailurepolicy::Union{Absent,IoK8sApiBatchV1PodFailurePolicy,Nothing} = ABSENT + podreplacementpolicy::Union{Absent,Nothing,String} = ABSENT + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + successpolicy::Union{Absent,IoK8sApiBatchV1SuccessPolicy,Nothing} = ABSENT + suspend::Union{Absent,Bool,Nothing} = ABSENT + template::IoK8sApiCoreV1PodTemplateSpec + ttlsecondsafterfinished::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1JobSpec}, value) = _decode(IoK8sApiBatchV1JobSpec, value, true) +function _decode(::Type{IoK8sApiBatchV1JobSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobSpec"), _openapi_raw, "decoding IoK8sApiBatchV1JobSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1JobSpec") + _openapi_field_activedeadlineseconds = haskey(_openapi_object, "activeDeadlineSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["activeDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_backofflimit = haskey(_openapi_object, "backoffLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["backoffLimit"], _openapi_validate) : ABSENT + _openapi_field_backofflimitperindex = haskey(_openapi_object, "backoffLimitPerIndex") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["backoffLimitPerIndex"], _openapi_validate) : ABSENT + _openapi_field_completionmode = haskey(_openapi_object, "completionMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["completionMode"], _openapi_validate) : ABSENT + _openapi_field_completions = haskey(_openapi_object, "completions") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["completions"], _openapi_validate) : ABSENT + _openapi_field_managedby = haskey(_openapi_object, "managedBy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["managedBy"], _openapi_validate) : ABSENT + _openapi_field_manualselector = haskey(_openapi_object, "manualSelector") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["manualSelector"], _openapi_validate) : ABSENT + _openapi_field_maxfailedindexes = haskey(_openapi_object, "maxFailedIndexes") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["maxFailedIndexes"], _openapi_validate) : ABSENT + _openapi_field_parallelism = haskey(_openapi_object, "parallelism") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["parallelism"], _openapi_validate) : ABSENT + _openapi_field_podfailurepolicy = haskey(_openapi_object, "podFailurePolicy") ? _decode(Union{Absent,IoK8sApiBatchV1PodFailurePolicy,Nothing}, _openapi_object["podFailurePolicy"], _openapi_validate) : ABSENT + _openapi_field_podreplacementpolicy = haskey(_openapi_object, "podReplacementPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podReplacementPolicy"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_successpolicy = haskey(_openapi_object, "successPolicy") ? _decode(Union{Absent,IoK8sApiBatchV1SuccessPolicy,Nothing}, _openapi_object["successPolicy"], _openapi_validate) : ABSENT + _openapi_field_suspend = haskey(_openapi_object, "suspend") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["suspend"], _openapi_validate) : ABSENT + _openapi_field_template = _decode(IoK8sApiCoreV1PodTemplateSpec, _required(_openapi_object, "template", "IoK8sApiBatchV1JobSpec"), _openapi_validate) + _openapi_field_ttlsecondsafterfinished = haskey(_openapi_object, "ttlSecondsAfterFinished") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["ttlSecondsAfterFinished"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("activeDeadlineSeconds","backoffLimit","backoffLimitPerIndex","completionMode","completions","managedBy","manualSelector","maxFailedIndexes","parallelism","podFailurePolicy","podReplacementPolicy","selector","successPolicy","suspend","template","ttlSecondsAfterFinished") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1JobSpec(; activedeadlineseconds = _openapi_field_activedeadlineseconds, backofflimit = _openapi_field_backofflimit, backofflimitperindex = _openapi_field_backofflimitperindex, completionmode = _openapi_field_completionmode, completions = _openapi_field_completions, managedby = _openapi_field_managedby, manualselector = _openapi_field_manualselector, maxfailedindexes = _openapi_field_maxfailedindexes, parallelism = _openapi_field_parallelism, podfailurepolicy = _openapi_field_podfailurepolicy, podreplacementpolicy = _openapi_field_podreplacementpolicy, selector = _openapi_field_selector, successpolicy = _openapi_field_successpolicy, suspend = _openapi_field_suspend, template = _openapi_field_template, ttlsecondsafterfinished = _openapi_field_ttlsecondsafterfinished, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1JobSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.activedeadlineseconds isa Absent || (_openapi_output["activeDeadlineSeconds"] = _encode(_openapi_value.activedeadlineseconds)) + _openapi_value.backofflimit isa Absent || (_openapi_output["backoffLimit"] = _encode(_openapi_value.backofflimit)) + _openapi_value.backofflimitperindex isa Absent || (_openapi_output["backoffLimitPerIndex"] = _encode(_openapi_value.backofflimitperindex)) + _openapi_value.completionmode isa Absent || (_openapi_output["completionMode"] = _encode(_openapi_value.completionmode)) + _openapi_value.completions isa Absent || (_openapi_output["completions"] = _encode(_openapi_value.completions)) + _openapi_value.managedby isa Absent || (_openapi_output["managedBy"] = _encode(_openapi_value.managedby)) + _openapi_value.manualselector isa Absent || (_openapi_output["manualSelector"] = _encode(_openapi_value.manualselector)) + _openapi_value.maxfailedindexes isa Absent || (_openapi_output["maxFailedIndexes"] = _encode(_openapi_value.maxfailedindexes)) + _openapi_value.parallelism isa Absent || (_openapi_output["parallelism"] = _encode(_openapi_value.parallelism)) + _openapi_value.podfailurepolicy isa Absent || (_openapi_output["podFailurePolicy"] = _encode(_openapi_value.podfailurepolicy)) + _openapi_value.podreplacementpolicy isa Absent || (_openapi_output["podReplacementPolicy"] = _encode(_openapi_value.podreplacementpolicy)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.successpolicy isa Absent || (_openapi_output["successPolicy"] = _encode(_openapi_value.successpolicy)) + _openapi_value.suspend isa Absent || (_openapi_output["suspend"] = _encode(_openapi_value.suspend)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + _openapi_value.ttlsecondsafterfinished isa Absent || (_openapi_output["ttlSecondsAfterFinished"] = _encode(_openapi_value.ttlsecondsafterfinished)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobSpec"), _openapi_output, "encoding IoK8sApiBatchV1JobSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1JobSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.activedeadlineseconds isa Absent || push!(_openapi_output, "activeDeadlineSeconds" => _openapi_value.activedeadlineseconds) + _openapi_value.backofflimit isa Absent || push!(_openapi_output, "backoffLimit" => _openapi_value.backofflimit) + _openapi_value.backofflimitperindex isa Absent || push!(_openapi_output, "backoffLimitPerIndex" => _openapi_value.backofflimitperindex) + _openapi_value.completionmode isa Absent || push!(_openapi_output, "completionMode" => _openapi_value.completionmode) + _openapi_value.completions isa Absent || push!(_openapi_output, "completions" => _openapi_value.completions) + _openapi_value.managedby isa Absent || push!(_openapi_output, "managedBy" => _openapi_value.managedby) + _openapi_value.manualselector isa Absent || push!(_openapi_output, "manualSelector" => _openapi_value.manualselector) + _openapi_value.maxfailedindexes isa Absent || push!(_openapi_output, "maxFailedIndexes" => _openapi_value.maxfailedindexes) + _openapi_value.parallelism isa Absent || push!(_openapi_output, "parallelism" => _openapi_value.parallelism) + _openapi_value.podfailurepolicy isa Absent || push!(_openapi_output, "podFailurePolicy" => _openapi_value.podfailurepolicy) + _openapi_value.podreplacementpolicy isa Absent || push!(_openapi_output, "podReplacementPolicy" => _openapi_value.podreplacementpolicy) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.successpolicy isa Absent || push!(_openapi_output, "successPolicy" => _openapi_value.successpolicy) + _openapi_value.suspend isa Absent || push!(_openapi_output, "suspend" => _openapi_value.suspend) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + _openapi_value.ttlsecondsafterfinished isa Absent || push!(_openapi_output, "ttlSecondsAfterFinished" => _openapi_value.ttlsecondsafterfinished) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1JobTemplateSpec + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiBatchV1JobSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1JobTemplateSpec}, value) = _decode(IoK8sApiBatchV1JobTemplateSpec, value, true) +function _decode(::Type{IoK8sApiBatchV1JobTemplateSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec"), _openapi_raw, "decoding IoK8sApiBatchV1JobTemplateSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1JobTemplateSpec") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiBatchV1JobSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1JobTemplateSpec(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1JobTemplateSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobTemplateSpec"), _openapi_output, "encoding IoK8sApiBatchV1JobTemplateSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1JobTemplateSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1CronJobSpec + concurrencypolicy::Union{Absent,Nothing,String} = ABSENT + failedjobshistorylimit::Union{Absent,Int32,Nothing} = ABSENT + jobtemplate::IoK8sApiBatchV1JobTemplateSpec + schedule::String + startingdeadlineseconds::Union{Absent,Int64,Nothing} = ABSENT + successfuljobshistorylimit::Union{Absent,Int32,Nothing} = ABSENT + suspend::Union{Absent,Bool,Nothing} = ABSENT + timezone::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1CronJobSpec}, value) = _decode(IoK8sApiBatchV1CronJobSpec, value, true) +function _decode(::Type{IoK8sApiBatchV1CronJobSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobSpec"), _openapi_raw, "decoding IoK8sApiBatchV1CronJobSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1CronJobSpec") + _openapi_field_concurrencypolicy = haskey(_openapi_object, "concurrencyPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["concurrencyPolicy"], _openapi_validate) : ABSENT + _openapi_field_failedjobshistorylimit = haskey(_openapi_object, "failedJobsHistoryLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["failedJobsHistoryLimit"], _openapi_validate) : ABSENT + _openapi_field_jobtemplate = _decode(IoK8sApiBatchV1JobTemplateSpec, _required(_openapi_object, "jobTemplate", "IoK8sApiBatchV1CronJobSpec"), _openapi_validate) + _openapi_field_schedule = _decode(String, _required(_openapi_object, "schedule", "IoK8sApiBatchV1CronJobSpec"), _openapi_validate) + _openapi_field_startingdeadlineseconds = haskey(_openapi_object, "startingDeadlineSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["startingDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_successfuljobshistorylimit = haskey(_openapi_object, "successfulJobsHistoryLimit") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["successfulJobsHistoryLimit"], _openapi_validate) : ABSENT + _openapi_field_suspend = haskey(_openapi_object, "suspend") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["suspend"], _openapi_validate) : ABSENT + _openapi_field_timezone = haskey(_openapi_object, "timeZone") ? _decode(Union{Absent,Nothing,String}, _openapi_object["timeZone"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("concurrencyPolicy","failedJobsHistoryLimit","jobTemplate","schedule","startingDeadlineSeconds","successfulJobsHistoryLimit","suspend","timeZone") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1CronJobSpec(; concurrencypolicy = _openapi_field_concurrencypolicy, failedjobshistorylimit = _openapi_field_failedjobshistorylimit, jobtemplate = _openapi_field_jobtemplate, schedule = _openapi_field_schedule, startingdeadlineseconds = _openapi_field_startingdeadlineseconds, successfuljobshistorylimit = _openapi_field_successfuljobshistorylimit, suspend = _openapi_field_suspend, timezone = _openapi_field_timezone, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1CronJobSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.concurrencypolicy isa Absent || (_openapi_output["concurrencyPolicy"] = _encode(_openapi_value.concurrencypolicy)) + _openapi_value.failedjobshistorylimit isa Absent || (_openapi_output["failedJobsHistoryLimit"] = _encode(_openapi_value.failedjobshistorylimit)) + _openapi_value.jobtemplate isa Absent || (_openapi_output["jobTemplate"] = _encode(_openapi_value.jobtemplate)) + _openapi_value.schedule isa Absent || (_openapi_output["schedule"] = _encode(_openapi_value.schedule)) + _openapi_value.startingdeadlineseconds isa Absent || (_openapi_output["startingDeadlineSeconds"] = _encode(_openapi_value.startingdeadlineseconds)) + _openapi_value.successfuljobshistorylimit isa Absent || (_openapi_output["successfulJobsHistoryLimit"] = _encode(_openapi_value.successfuljobshistorylimit)) + _openapi_value.suspend isa Absent || (_openapi_output["suspend"] = _encode(_openapi_value.suspend)) + _openapi_value.timezone isa Absent || (_openapi_output["timeZone"] = _encode(_openapi_value.timezone)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobSpec"), _openapi_output, "encoding IoK8sApiBatchV1CronJobSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1CronJobSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.concurrencypolicy isa Absent || push!(_openapi_output, "concurrencyPolicy" => _openapi_value.concurrencypolicy) + _openapi_value.failedjobshistorylimit isa Absent || push!(_openapi_output, "failedJobsHistoryLimit" => _openapi_value.failedjobshistorylimit) + _openapi_value.jobtemplate isa Absent || push!(_openapi_output, "jobTemplate" => _openapi_value.jobtemplate) + _openapi_value.schedule isa Absent || push!(_openapi_output, "schedule" => _openapi_value.schedule) + _openapi_value.startingdeadlineseconds isa Absent || push!(_openapi_output, "startingDeadlineSeconds" => _openapi_value.startingdeadlineseconds) + _openapi_value.successfuljobshistorylimit isa Absent || push!(_openapi_output, "successfulJobsHistoryLimit" => _openapi_value.successfuljobshistorylimit) + _openapi_value.suspend isa Absent || push!(_openapi_output, "suspend" => _openapi_value.suspend) + _openapi_value.timezone isa Absent || push!(_openapi_output, "timeZone" => _openapi_value.timezone) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectReference}, value) = _decode(IoK8sApiCoreV1ObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath","kind","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectReference(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1CronJobStatus + active::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ObjectReference}}} = ABSENT + lastscheduletime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lastsuccessfultime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1CronJobStatus}, value) = _decode(IoK8sApiBatchV1CronJobStatus, value, true) +function _decode(::Type{IoK8sApiBatchV1CronJobStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobStatus"), _openapi_raw, "decoding IoK8sApiBatchV1CronJobStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1CronJobStatus") + _openapi_field_active = haskey(_openapi_object, "active") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ObjectReference}}}, _openapi_object["active"], _openapi_validate) : ABSENT + _openapi_field_lastscheduletime = haskey(_openapi_object, "lastScheduleTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastScheduleTime"], _openapi_validate) : ABSENT + _openapi_field_lastsuccessfultime = haskey(_openapi_object, "lastSuccessfulTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastSuccessfulTime"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("active","lastScheduleTime","lastSuccessfulTime") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1CronJobStatus(; active = _openapi_field_active, lastscheduletime = _openapi_field_lastscheduletime, lastsuccessfultime = _openapi_field_lastsuccessfultime, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1CronJobStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.active isa Absent || (_openapi_output["active"] = _encode(_openapi_value.active)) + _openapi_value.lastscheduletime isa Absent || (_openapi_output["lastScheduleTime"] = _encode(_openapi_value.lastscheduletime)) + _openapi_value.lastsuccessfultime isa Absent || (_openapi_output["lastSuccessfulTime"] = _encode(_openapi_value.lastsuccessfultime)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobStatus"), _openapi_output, "encoding IoK8sApiBatchV1CronJobStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1CronJobStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.active isa Absent || push!(_openapi_output, "active" => _openapi_value.active) + _openapi_value.lastscheduletime isa Absent || push!(_openapi_output, "lastScheduleTime" => _openapi_value.lastscheduletime) + _openapi_value.lastsuccessfultime isa Absent || push!(_openapi_output, "lastSuccessfulTime" => _openapi_value.lastsuccessfultime) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1CronJob + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiBatchV1CronJobSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiBatchV1CronJobStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1CronJob}, value) = _decode(IoK8sApiBatchV1CronJob, value, true) +function _decode(::Type{IoK8sApiBatchV1CronJob}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJob"), _openapi_raw, "decoding IoK8sApiBatchV1CronJob"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1CronJob") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiBatchV1CronJobSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiBatchV1CronJobStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1CronJob(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1CronJob) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJob"), _openapi_output, "encoding IoK8sApiBatchV1CronJob"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1CronJob) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1CronJobList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiBatchV1CronJob}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1CronJobList}, value) = _decode(IoK8sApiBatchV1CronJobList, value, true) +function _decode(::Type{IoK8sApiBatchV1CronJobList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobList"), _openapi_raw, "decoding IoK8sApiBatchV1CronJobList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1CronJobList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiBatchV1CronJob}}, _required(_openapi_object, "items", "IoK8sApiBatchV1CronJobList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1CronJobList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1CronJobList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.CronJobList"), _openapi_output, "encoding IoK8sApiBatchV1CronJobList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1CronJobList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1JobCondition + lastprobetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1JobCondition}, value) = _decode(IoK8sApiBatchV1JobCondition, value, true) +function _decode(::Type{IoK8sApiBatchV1JobCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobCondition"), _openapi_raw, "decoding IoK8sApiBatchV1JobCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1JobCondition") + _openapi_field_lastprobetime = haskey(_openapi_object, "lastProbeTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastProbeTime"], _openapi_validate) : ABSENT + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiBatchV1JobCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiBatchV1JobCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastProbeTime","lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1JobCondition(; lastprobetime = _openapi_field_lastprobetime, lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1JobCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastprobetime isa Absent || (_openapi_output["lastProbeTime"] = _encode(_openapi_value.lastprobetime)) + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobCondition"), _openapi_output, "encoding IoK8sApiBatchV1JobCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1JobCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastprobetime isa Absent || push!(_openapi_output, "lastProbeTime" => _openapi_value.lastprobetime) + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1UncountedTerminatedPods + failed::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + succeeded::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1UncountedTerminatedPods}, value) = _decode(IoK8sApiBatchV1UncountedTerminatedPods, value, true) +function _decode(::Type{IoK8sApiBatchV1UncountedTerminatedPods}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods"), _openapi_raw, "decoding IoK8sApiBatchV1UncountedTerminatedPods"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1UncountedTerminatedPods") + _openapi_field_failed = haskey(_openapi_object, "failed") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["failed"], _openapi_validate) : ABSENT + _openapi_field_succeeded = haskey(_openapi_object, "succeeded") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["succeeded"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("failed","succeeded") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1UncountedTerminatedPods(; failed = _openapi_field_failed, succeeded = _openapi_field_succeeded, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1UncountedTerminatedPods) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.failed isa Absent || (_openapi_output["failed"] = _encode(_openapi_value.failed)) + _openapi_value.succeeded isa Absent || (_openapi_output["succeeded"] = _encode(_openapi_value.succeeded)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.UncountedTerminatedPods"), _openapi_output, "encoding IoK8sApiBatchV1UncountedTerminatedPods"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1UncountedTerminatedPods) + _openapi_output = Pair{String,Any}[] + _openapi_value.failed isa Absent || push!(_openapi_output, "failed" => _openapi_value.failed) + _openapi_value.succeeded isa Absent || push!(_openapi_output, "succeeded" => _openapi_value.succeeded) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1JobStatus + active::Union{Absent,Int32,Nothing} = ABSENT + completedindexes::Union{Absent,Nothing,String} = ABSENT + completiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiBatchV1JobCondition}}} = ABSENT + failed::Union{Absent,Int32,Nothing} = ABSENT + failedindexes::Union{Absent,Nothing,String} = ABSENT + ready::Union{Absent,Int32,Nothing} = ABSENT + starttime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + succeeded::Union{Absent,Int32,Nothing} = ABSENT + terminating::Union{Absent,Int32,Nothing} = ABSENT + uncountedterminatedpods::Union{Absent,IoK8sApiBatchV1UncountedTerminatedPods,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1JobStatus}, value) = _decode(IoK8sApiBatchV1JobStatus, value, true) +function _decode(::Type{IoK8sApiBatchV1JobStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobStatus"), _openapi_raw, "decoding IoK8sApiBatchV1JobStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1JobStatus") + _openapi_field_active = haskey(_openapi_object, "active") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["active"], _openapi_validate) : ABSENT + _openapi_field_completedindexes = haskey(_openapi_object, "completedIndexes") ? _decode(Union{Absent,Nothing,String}, _openapi_object["completedIndexes"], _openapi_validate) : ABSENT + _openapi_field_completiontime = haskey(_openapi_object, "completionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["completionTime"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiBatchV1JobCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_failed = haskey(_openapi_object, "failed") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["failed"], _openapi_validate) : ABSENT + _openapi_field_failedindexes = haskey(_openapi_object, "failedIndexes") ? _decode(Union{Absent,Nothing,String}, _openapi_object["failedIndexes"], _openapi_validate) : ABSENT + _openapi_field_ready = haskey(_openapi_object, "ready") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["ready"], _openapi_validate) : ABSENT + _openapi_field_starttime = haskey(_openapi_object, "startTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["startTime"], _openapi_validate) : ABSENT + _openapi_field_succeeded = haskey(_openapi_object, "succeeded") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["succeeded"], _openapi_validate) : ABSENT + _openapi_field_terminating = haskey(_openapi_object, "terminating") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["terminating"], _openapi_validate) : ABSENT + _openapi_field_uncountedterminatedpods = haskey(_openapi_object, "uncountedTerminatedPods") ? _decode(Union{Absent,IoK8sApiBatchV1UncountedTerminatedPods,Nothing}, _openapi_object["uncountedTerminatedPods"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("active","completedIndexes","completionTime","conditions","failed","failedIndexes","ready","startTime","succeeded","terminating","uncountedTerminatedPods") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1JobStatus(; active = _openapi_field_active, completedindexes = _openapi_field_completedindexes, completiontime = _openapi_field_completiontime, conditions = _openapi_field_conditions, failed = _openapi_field_failed, failedindexes = _openapi_field_failedindexes, ready = _openapi_field_ready, starttime = _openapi_field_starttime, succeeded = _openapi_field_succeeded, terminating = _openapi_field_terminating, uncountedterminatedpods = _openapi_field_uncountedterminatedpods, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1JobStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.active isa Absent || (_openapi_output["active"] = _encode(_openapi_value.active)) + _openapi_value.completedindexes isa Absent || (_openapi_output["completedIndexes"] = _encode(_openapi_value.completedindexes)) + _openapi_value.completiontime isa Absent || (_openapi_output["completionTime"] = _encode(_openapi_value.completiontime)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.failed isa Absent || (_openapi_output["failed"] = _encode(_openapi_value.failed)) + _openapi_value.failedindexes isa Absent || (_openapi_output["failedIndexes"] = _encode(_openapi_value.failedindexes)) + _openapi_value.ready isa Absent || (_openapi_output["ready"] = _encode(_openapi_value.ready)) + _openapi_value.starttime isa Absent || (_openapi_output["startTime"] = _encode(_openapi_value.starttime)) + _openapi_value.succeeded isa Absent || (_openapi_output["succeeded"] = _encode(_openapi_value.succeeded)) + _openapi_value.terminating isa Absent || (_openapi_output["terminating"] = _encode(_openapi_value.terminating)) + _openapi_value.uncountedterminatedpods isa Absent || (_openapi_output["uncountedTerminatedPods"] = _encode(_openapi_value.uncountedterminatedpods)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobStatus"), _openapi_output, "encoding IoK8sApiBatchV1JobStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1JobStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.active isa Absent || push!(_openapi_output, "active" => _openapi_value.active) + _openapi_value.completedindexes isa Absent || push!(_openapi_output, "completedIndexes" => _openapi_value.completedindexes) + _openapi_value.completiontime isa Absent || push!(_openapi_output, "completionTime" => _openapi_value.completiontime) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.failed isa Absent || push!(_openapi_output, "failed" => _openapi_value.failed) + _openapi_value.failedindexes isa Absent || push!(_openapi_output, "failedIndexes" => _openapi_value.failedindexes) + _openapi_value.ready isa Absent || push!(_openapi_output, "ready" => _openapi_value.ready) + _openapi_value.starttime isa Absent || push!(_openapi_output, "startTime" => _openapi_value.starttime) + _openapi_value.succeeded isa Absent || push!(_openapi_output, "succeeded" => _openapi_value.succeeded) + _openapi_value.terminating isa Absent || push!(_openapi_output, "terminating" => _openapi_value.terminating) + _openapi_value.uncountedterminatedpods isa Absent || push!(_openapi_output, "uncountedTerminatedPods" => _openapi_value.uncountedterminatedpods) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1Job + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiBatchV1JobSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiBatchV1JobStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1Job}, value) = _decode(IoK8sApiBatchV1Job, value, true) +function _decode(::Type{IoK8sApiBatchV1Job}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.Job"), _openapi_raw, "decoding IoK8sApiBatchV1Job"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1Job") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiBatchV1JobSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiBatchV1JobStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1Job(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1Job) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.Job"), _openapi_output, "encoding IoK8sApiBatchV1Job"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1Job) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiBatchV1JobList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiBatchV1Job}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiBatchV1JobList}, value) = _decode(IoK8sApiBatchV1JobList, value, true) +function _decode(::Type{IoK8sApiBatchV1JobList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobList"), _openapi_raw, "decoding IoK8sApiBatchV1JobList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiBatchV1JobList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiBatchV1Job}}, _required(_openapi_object, "items", "IoK8sApiBatchV1JobList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiBatchV1JobList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiBatchV1JobList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.api.batch.v1.JobList"), _openapi_output, "encoding IoK8sApiBatchV1JobList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiBatchV1JobList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getbatchv1apiresources = ( + id = "getBatchV1APIResources", + method = "GET", + path = "/apis/batch/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getbatchv1apiresources(...)\n\nget available resources\n\n`GET /apis/batch/v1/`" +function getbatchv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getbatchv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listbatchv1cronjobforallnamespaces = ( + id = "listBatchV1CronJobForAllNamespaces", + method = "GET", + path = "/apis/batch/v1/cronjobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1cronjobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listbatchv1cronjobforallnamespaces(...)\n\nlist or watch objects of kind CronJob\n\n`GET /apis/batch/v1/cronjobs`" +function listbatchv1cronjobforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listbatchv1cronjobforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listbatchv1jobforallnamespaces = ( + id = "listBatchV1JobForAllNamespaces", + method = "GET", + path = "/apis/batch/v1/jobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1jobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listbatchv1jobforallnamespaces(...)\n\nlist or watch objects of kind Job\n\n`GET /apis/batch/v1/jobs`" +function listbatchv1jobforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listbatchv1jobforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletebatchv1collectionnamespacedcronjob = ( + id = "deleteBatchV1CollectionNamespacedCronJob", + method = "DELETE", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletebatchv1collectionnamespacedcronjob(...)\n\ndelete collection of CronJob\n\n`DELETE /apis/batch/v1/namespaces/{namespace}/cronjobs`" +function deletebatchv1collectionnamespacedcronjob(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletebatchv1collectionnamespacedcronjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listbatchv1namespacedcronjob = ( + id = "listBatchV1NamespacedCronJob", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listbatchv1namespacedcronjob(...)\n\nlist or watch objects of kind CronJob\n\n`GET /apis/batch/v1/namespaces/{namespace}/cronjobs`" +function listbatchv1namespacedcronjob(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listbatchv1namespacedcronjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createbatchv1namespacedcronjob = ( + id = "createBatchV1NamespacedCronJob", + method = "POST", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createbatchv1namespacedcronjob(...)\n\ncreate a CronJob\n\n`POST /apis/batch/v1/namespaces/{namespace}/cronjobs`" +function createbatchv1namespacedcronjob(namespace::String, body::IoK8sApiBatchV1CronJob; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createbatchv1namespacedcronjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletebatchv1namespacedcronjob = ( + id = "deleteBatchV1NamespacedCronJob", + method = "DELETE", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletebatchv1namespacedcronjob(...)\n\ndelete a CronJob\n\n`DELETE /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}`" +function deletebatchv1namespacedcronjob(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletebatchv1namespacedcronjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readbatchv1namespacedcronjob = ( + id = "readBatchV1NamespacedCronJob", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readbatchv1namespacedcronjob(...)\n\nread the specified CronJob\n\n`GET /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}`" +function readbatchv1namespacedcronjob(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readbatchv1namespacedcronjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchbatchv1namespacedcronjob = ( + id = "patchBatchV1NamespacedCronJob", + method = "PATCH", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchbatchv1namespacedcronjob(...)\n\npartially update the specified CronJob\n\n`PATCH /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}`" +function patchbatchv1namespacedcronjob(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchbatchv1namespacedcronjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacebatchv1namespacedcronjob = ( + id = "replaceBatchV1NamespacedCronJob", + method = "PUT", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacebatchv1namespacedcronjob(...)\n\nreplace the specified CronJob\n\n`PUT /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}`" +function replacebatchv1namespacedcronjob(namespace::String, name::String, body::IoK8sApiBatchV1CronJob; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacebatchv1namespacedcronjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readbatchv1namespacedcronjobstatus = ( + id = "readBatchV1NamespacedCronJobStatus", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readbatchv1namespacedcronjobstatus(...)\n\nread status of the specified CronJob\n\n`GET /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status`" +function readbatchv1namespacedcronjobstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readbatchv1namespacedcronjobstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchbatchv1namespacedcronjobstatus = ( + id = "patchBatchV1NamespacedCronJobStatus", + method = "PATCH", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchbatchv1namespacedcronjobstatus(...)\n\npartially update status of the specified CronJob\n\n`PATCH /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status`" +function patchbatchv1namespacedcronjobstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchbatchv1namespacedcronjobstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacebatchv1namespacedcronjobstatus = ( + id = "replaceBatchV1NamespacedCronJobStatus", + method = "PUT", + path = "/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1CronJob, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1cronjobs~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacebatchv1namespacedcronjobstatus(...)\n\nreplace status of the specified CronJob\n\n`PUT /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status`" +function replacebatchv1namespacedcronjobstatus(namespace::String, name::String, body::IoK8sApiBatchV1CronJob; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacebatchv1namespacedcronjobstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletebatchv1collectionnamespacedjob = ( + id = "deleteBatchV1CollectionNamespacedJob", + method = "DELETE", + path = "/apis/batch/v1/namespaces/{namespace}/jobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletebatchv1collectionnamespacedjob(...)\n\ndelete collection of Job\n\n`DELETE /apis/batch/v1/namespaces/{namespace}/jobs`" +function deletebatchv1collectionnamespacedjob(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletebatchv1collectionnamespacedjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listbatchv1namespacedjob = ( + id = "listBatchV1NamespacedJob", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/jobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiBatchV1JobList, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listbatchv1namespacedjob(...)\n\nlist or watch objects of kind Job\n\n`GET /apis/batch/v1/namespaces/{namespace}/jobs`" +function listbatchv1namespacedjob(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listbatchv1namespacedjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createbatchv1namespacedjob = ( + id = "createBatchV1NamespacedJob", + method = "POST", + path = "/apis/batch/v1/namespaces/{namespace}/jobs", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createbatchv1namespacedjob(...)\n\ncreate a Job\n\n`POST /apis/batch/v1/namespaces/{namespace}/jobs`" +function createbatchv1namespacedjob(namespace::String, body::IoK8sApiBatchV1Job; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createbatchv1namespacedjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletebatchv1namespacedjob = ( + id = "deleteBatchV1NamespacedJob", + method = "DELETE", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletebatchv1namespacedjob(...)\n\ndelete a Job\n\n`DELETE /apis/batch/v1/namespaces/{namespace}/jobs/{name}`" +function deletebatchv1namespacedjob(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletebatchv1namespacedjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readbatchv1namespacedjob = ( + id = "readBatchV1NamespacedJob", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readbatchv1namespacedjob(...)\n\nread the specified Job\n\n`GET /apis/batch/v1/namespaces/{namespace}/jobs/{name}`" +function readbatchv1namespacedjob(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readbatchv1namespacedjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchbatchv1namespacedjob = ( + id = "patchBatchV1NamespacedJob", + method = "PATCH", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchbatchv1namespacedjob(...)\n\npartially update the specified Job\n\n`PATCH /apis/batch/v1/namespaces/{namespace}/jobs/{name}`" +function patchbatchv1namespacedjob(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchbatchv1namespacedjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacebatchv1namespacedjob = ( + id = "replaceBatchV1NamespacedJob", + method = "PUT", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacebatchv1namespacedjob(...)\n\nreplace the specified Job\n\n`PUT /apis/batch/v1/namespaces/{namespace}/jobs/{name}`" +function replacebatchv1namespacedjob(namespace::String, name::String, body::IoK8sApiBatchV1Job; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacebatchv1namespacedjob, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readbatchv1namespacedjobstatus = ( + id = "readBatchV1NamespacedJobStatus", + method = "GET", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readbatchv1namespacedjobstatus(...)\n\nread status of the specified Job\n\n`GET /apis/batch/v1/namespaces/{namespace}/jobs/{name}/status`" +function readbatchv1namespacedjobstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readbatchv1namespacedjobstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchbatchv1namespacedjobstatus = ( + id = "patchBatchV1NamespacedJobStatus", + method = "PATCH", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchbatchv1namespacedjobstatus(...)\n\npartially update status of the specified Job\n\n`PATCH /apis/batch/v1/namespaces/{namespace}/jobs/{name}/status`" +function patchbatchv1namespacedjobstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchbatchv1namespacedjobstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacebatchv1namespacedjobstatus = ( + id = "replaceBatchV1NamespacedJobStatus", + method = "PUT", + path = "/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiBatchV1Job, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1namespaces~1{namespace}~1jobs~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacebatchv1namespacedjobstatus(...)\n\nreplace status of the specified Job\n\n`PUT /apis/batch/v1/namespaces/{namespace}/jobs/{name}/status`" +function replacebatchv1namespacedjobstatus(namespace::String, name::String, body::IoK8sApiBatchV1Job; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacebatchv1namespacedjobstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1cronjoblistforallnamespaces = ( + id = "watchBatchV1CronJobListForAllNamespaces", + method = "GET", + path = "/apis/batch/v1/watch/cronjobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1cronjobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1cronjoblistforallnamespaces(...)\n\nwatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/batch/v1/watch/cronjobs`" +function watchbatchv1cronjoblistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1cronjoblistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1joblistforallnamespaces = ( + id = "watchBatchV1JobListForAllNamespaces", + method = "GET", + path = "/apis/batch/v1/watch/jobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1jobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1joblistforallnamespaces(...)\n\nwatch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/batch/v1/watch/jobs`" +function watchbatchv1joblistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1joblistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1namespacedcronjoblist = ( + id = "watchBatchV1NamespacedCronJobList", + method = "GET", + path = "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1namespacedcronjoblist(...)\n\nwatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/batch/v1/watch/namespaces/{namespace}/cronjobs`" +function watchbatchv1namespacedcronjoblist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1namespacedcronjoblist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1namespacedcronjob = ( + id = "watchBatchV1NamespacedCronJob", + method = "GET", + path = "/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1cronjobs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1namespacedcronjob(...)\n\nwatch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}`" +function watchbatchv1namespacedcronjob(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1namespacedcronjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1namespacedjoblist = ( + id = "watchBatchV1NamespacedJobList", + method = "GET", + path = "/apis/batch/v1/watch/namespaces/{namespace}/jobs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1namespacedjoblist(...)\n\nwatch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/batch/v1/watch/namespaces/{namespace}/jobs`" +function watchbatchv1namespacedjoblist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1namespacedjoblist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchbatchv1namespacedjob = ( + id = "watchBatchV1NamespacedJob", + method = "GET", + path = "/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-f5cfb6d240ccdbaef1d1.json", pointer = "/paths/~1apis~1batch~1v1~1watch~1namespaces~1{namespace}~1jobs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchbatchv1namespacedjob(...)\n\nwatch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}`" +function watchbatchv1namespacedjob(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchbatchv1namespacedjob, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sBatchV1 diff --git a/src/ApiImpl/generated/K8sCertificatesK8sIoV1.jl b/src/ApiImpl/generated/K8sCertificatesK8sIoV1.jl new file mode 100644 index 00000000..e5681453 --- /dev/null +++ b/src/ApiImpl/generated/K8sCertificatesK8sIoV1.jl @@ -0,0 +1,1835 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sCertificatesK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", retrieval = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.certificates.v1.CertificateSigningRequest\":{\"description\":\"CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued.\\n\\nKubelets use this API to obtain:\\n 1. client certificates to authenticate to kube-apiserver (with the \\\"kubernetes.io/kube-apiserver-client-kubelet\\\" signerName).\\n 2. serving certificates for TLS endpoints kube-apiserver can connect to securely (with the \\\"kubernetes.io/kubelet-serving\\\" signerName).\\n\\nThis API can be used to request client certificates to authenticate to kube-apiserver (with the \\\"kubernetes.io/kube-apiserver-client\\\" signerName), or to obtain certificates from custom non-Kubernetes signers.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}]},\"io.k8s.api.certificates.v1.CertificateSigningRequestCondition\":{\"description\":\"CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastUpdateTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message contains a human readable message with details about the request state\",\"type\":\"string\"},\"reason\":{\"description\":\"reason indicates a brief reason for the request state\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status of the condition, one of True, False, Unknown. Approved, Denied, and Failed conditions may not be \\\"False\\\" or \\\"Unknown\\\".\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type of the condition. Known conditions are \\\"Approved\\\", \\\"Denied\\\", and \\\"Failed\\\".\\n\\nAn \\\"Approved\\\" condition is added via the /approval subresource, indicating the request was approved and should be issued by the signer.\\n\\nA \\\"Denied\\\" condition is added via the /approval subresource, indicating the request was denied and should not be issued by the signer.\\n\\nA \\\"Failed\\\" condition is added via the /status subresource, indicating the signer failed to issue the certificate.\\n\\nApproved and Denied conditions are mutually exclusive. Approved, Denied, and Failed conditions cannot be removed once added.\\n\\nOnly one condition of a given type is allowed.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.certificates.v1.CertificateSigningRequestList\":{\"description\":\"CertificateSigningRequestList is a collection of CertificateSigningRequest objects\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a collection of CertificateSigningRequest objects\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequestList\",\"version\":\"v1\"}]},\"io.k8s.api.certificates.v1.CertificateSigningRequestSpec\":{\"description\":\"CertificateSigningRequestSpec contains the certificate request.\",\"properties\":{\"expirationSeconds\":{\"description\":\"expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration.\\n\\nThe v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager.\\n\\nCertificate signers may not honor this field for various reasons:\\n\\n 1. Old signer that is unaware of the field (such as the in-tree\\n implementations prior to v1.22)\\n 2. Signer whose configured maximum is shorter than the requested duration\\n 3. Signer whose configured minimum is longer than the requested duration\\n\\nThe minimum valid value for expirationSeconds is 600, i.e. 10 minutes.\",\"format\":\"int32\",\"type\":\"integer\"},\"extra\":{\"additionalProperties\":{\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":\"array\"},\"description\":\"extra contains extra attributes of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.\",\"type\":\"object\"},\"groups\":{\"description\":\"groups contains group membership of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"request\":{\"description\":\"request contains an x509 certificate signing request encoded in a \\\"CERTIFICATE REQUEST\\\" PEM block. When serialized as JSON or YAML, the data is additionally base64-encoded.\",\"format\":\"byte\",\"type\":\"string\"},\"signerName\":{\"default\":\"\",\"description\":\"signerName indicates the requested signer, and is a qualified name.\\n\\nList/watch requests for CertificateSigningRequests can filter on this field using a \\\"spec.signerName=NAME\\\" fieldSelector.\\n\\nWell-known Kubernetes signers are:\\n 1. \\\"kubernetes.io/kube-apiserver-client\\\": issues client certificates that can be used to authenticate to kube-apiserver.\\n Requests for this signer are never auto-approved by kube-controller-manager, can be issued by the \\\"csrsigning\\\" controller in kube-controller-manager.\\n 2. \\\"kubernetes.io/kube-apiserver-client-kubelet\\\": issues client certificates that kubelets use to authenticate to kube-apiserver.\\n Requests for this signer can be auto-approved by the \\\"csrapproving\\\" controller in kube-controller-manager, and can be issued by the \\\"csrsigning\\\" controller in kube-controller-manager.\\n 3. \\\"kubernetes.io/kubelet-serving\\\" issues serving certificates that kubelets use to serve TLS endpoints, which kube-apiserver can connect to securely.\\n Requests for this signer are never auto-approved by kube-controller-manager, and can be issued by the \\\"csrsigning\\\" controller in kube-controller-manager.\\n\\nMore details are available at https://k8s.io/docs/reference/access-authn-authz/certificate-signing-requests/#kubernetes-signers\\n\\nCustom signerNames can also be specified. The signer defines:\\n 1. Trust distribution: how trust (CA bundles) are distributed.\\n 2. Permitted subjects: and behavior when a disallowed subject is requested.\\n 3. Required, permitted, or forbidden x509 extensions in the request (including whether subjectAltNames are allowed, which types, restrictions on allowed values) and behavior when a disallowed extension is requested.\\n 4. Required, permitted, or forbidden key usages / extended key usages.\\n 5. Expiration/certificate lifetime: whether it is fixed by the signer, configurable by the admin.\\n 6. Whether or not requests for CA certificates are allowed.\",\"type\":\"string\"},\"uid\":{\"description\":\"uid contains the uid of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.\",\"type\":\"string\"},\"usages\":{\"description\":\"usages specifies a set of key usages requested in the issued certificate.\\n\\nRequests for TLS client certificates typically request: \\\"digital signature\\\", \\\"key encipherment\\\", \\\"client auth\\\".\\n\\nRequests for TLS serving certificates typically request: \\\"key encipherment\\\", \\\"digital signature\\\", \\\"server auth\\\".\\n\\nValid values are:\\n \\\"signing\\\", \\\"digital signature\\\", \\\"content commitment\\\",\\n \\\"key encipherment\\\", \\\"key agreement\\\", \\\"data encipherment\\\",\\n \\\"cert sign\\\", \\\"crl sign\\\", \\\"encipher only\\\", \\\"decipher only\\\", \\\"any\\\",\\n \\\"server auth\\\", \\\"client auth\\\",\\n \\\"code signing\\\", \\\"email protection\\\", \\\"s/mime\\\",\\n \\\"ipsec end system\\\", \\\"ipsec tunnel\\\", \\\"ipsec user\\\",\\n \\\"timestamping\\\", \\\"ocsp signing\\\", \\\"microsoft sgc\\\", \\\"netscape sgc\\\"\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"username\":{\"description\":\"username contains the name of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable.\",\"type\":\"string\"}},\"required\":[\"request\",\"signerName\"],\"type\":\"object\"},\"io.k8s.api.certificates.v1.CertificateSigningRequestStatus\":{\"description\":\"CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate.\",\"properties\":{\"certificate\":{\"description\":\"certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable.\\n\\nIf the certificate signing request is denied, a condition of type \\\"Denied\\\" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type \\\"Failed\\\" is added and this field remains empty.\\n\\nValidation requirements:\\n 1. certificate must contain one or more PEM blocks.\\n 2. All PEM blocks must have the \\\"CERTIFICATE\\\" label, contain no headers, and the encoded data\\n must be a BER-encoded ASN.1 Certificate structure as described in section 4 of RFC5280.\\n 3. Non-PEM content may appear before or after the \\\"CERTIFICATE\\\" PEM blocks and is unvalidated,\\n to allow for explanatory text as described in section 5.2 of RFC7468.\\n\\nIf more than one PEM block is present, and the definition of the requested spec.signerName does not indicate otherwise, the first block is the issued certificate, and subsequent blocks should be treated as intermediate certificates and presented in TLS handshakes.\\n\\nThe certificate is encoded in PEM format.\\n\\nWhen serialized as JSON or YAML, the data is additionally base64-encoded, so it consists of:\\n\\n base64(\\n -----BEGIN CERTIFICATE-----\\n ...\\n -----END CERTIFICATE-----\\n )\",\"format\":\"byte\",\"type\":\"string\"},\"conditions\":{\"description\":\"conditions applied to the request. Known conditions are \\\"Approved\\\", \\\"Denied\\\", and \\\"Failed\\\".\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/certificates.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getCertificatesV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"]}},\"/apis/certificates.k8s.io/v1/certificatesigningrequests\":{\"delete\":{\"description\":\"delete collection of CertificateSigningRequest\",\"operationId\":\"deleteCertificatesV1CollectionCertificateSigningRequest\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CertificateSigningRequest\",\"operationId\":\"listCertificatesV1CertificateSigningRequest\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CertificateSigningRequest\",\"operationId\":\"createCertificatesV1CertificateSigningRequest\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}}},\"/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}\":{\"delete\":{\"description\":\"delete a CertificateSigningRequest\",\"operationId\":\"deleteCertificatesV1CertificateSigningRequest\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CertificateSigningRequest\",\"operationId\":\"readCertificatesV1CertificateSigningRequest\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CertificateSigningRequest\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CertificateSigningRequest\",\"operationId\":\"patchCertificatesV1CertificateSigningRequest\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CertificateSigningRequest\",\"operationId\":\"replaceCertificatesV1CertificateSigningRequest\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}}},\"/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval\":{\"get\":{\"description\":\"read approval of the specified CertificateSigningRequest\",\"operationId\":\"readCertificatesV1CertificateSigningRequestApproval\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the CertificateSigningRequest\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update approval of the specified CertificateSigningRequest\",\"operationId\":\"patchCertificatesV1CertificateSigningRequestApproval\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace approval of the specified CertificateSigningRequest\",\"operationId\":\"replaceCertificatesV1CertificateSigningRequestApproval\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}}},\"/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status\":{\"get\":{\"description\":\"read status of the specified CertificateSigningRequest\",\"operationId\":\"readCertificatesV1CertificateSigningRequestStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the CertificateSigningRequest\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified CertificateSigningRequest\",\"operationId\":\"patchCertificatesV1CertificateSigningRequestStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified CertificateSigningRequest\",\"operationId\":\"replaceCertificatesV1CertificateSigningRequestStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}}},\"/apis/certificates.k8s.io/v1/watch/certificatesigningrequests\":{\"get\":{\"description\":\"watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCertificatesV1CertificateSigningRequestList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCertificatesV1CertificateSigningRequest\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-19e697dd14a7543656fb.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"certificates_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"certificates.k8s.io\",\"kind\":\"CertificateSigningRequest\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CertificateSigningRequest\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra + additional_properties::Dict{String,Vector{String}} = Dict{String,Vector{String}}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec/properties/extra"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra") + _openapi_additional_properties = Dict{String,Vector{String}}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Vector{String}, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec/properties/extra"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequestSpec + expirationseconds::Union{Absent,Int32,Nothing} = ABSENT + extra::Union{Absent,IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra,Nothing} = ABSENT + groups::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + request::Vector{UInt8} + signername::String + uid::Union{Absent,Nothing,String} = ABSENT + usages::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + username::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestSpec}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequestSpec, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequestSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequestSpec") + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_extra = haskey(_openapi_object, "extra") ? _decode(Union{Absent,IoK8sApiCertificatesV1CertificateSigningRequestSpecExtra,Nothing}, _openapi_object["extra"], _openapi_validate) : ABSENT + _openapi_field_groups = haskey(_openapi_object, "groups") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["groups"], _openapi_validate) : ABSENT + _openapi_field_request = _decode(Vector{UInt8}, _required(_openapi_object, "request", "IoK8sApiCertificatesV1CertificateSigningRequestSpec"), _openapi_validate) + _openapi_field_signername = _decode(String, _required(_openapi_object, "signerName", "IoK8sApiCertificatesV1CertificateSigningRequestSpec"), _openapi_validate) + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_field_usages = haskey(_openapi_object, "usages") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["usages"], _openapi_validate) : ABSENT + _openapi_field_username = haskey(_openapi_object, "username") ? _decode(Union{Absent,Nothing,String}, _openapi_object["username"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("expirationSeconds","extra","groups","request","signerName","uid","usages","username") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequestSpec(; expirationseconds = _openapi_field_expirationseconds, extra = _openapi_field_extra, groups = _openapi_field_groups, request = _openapi_field_request, signername = _openapi_field_signername, uid = _openapi_field_uid, usages = _openapi_field_usages, username = _openapi_field_username, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + _openapi_value.extra isa Absent || (_openapi_output["extra"] = _encode(_openapi_value.extra)) + _openapi_value.groups isa Absent || (_openapi_output["groups"] = _encode(_openapi_value.groups)) + _openapi_value.request isa Absent || (_openapi_output["request"] = _encode(_openapi_value.request)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + _openapi_value.usages isa Absent || (_openapi_output["usages"] = _encode(_openapi_value.usages)) + _openapi_value.username isa Absent || (_openapi_output["username"] = _encode(_openapi_value.username)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestSpec"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequestSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + _openapi_value.extra isa Absent || push!(_openapi_output, "extra" => _openapi_value.extra) + _openapi_value.groups isa Absent || push!(_openapi_output, "groups" => _openapi_value.groups) + _openapi_value.request isa Absent || push!(_openapi_output, "request" => _openapi_value.request) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + _openapi_value.usages isa Absent || push!(_openapi_output, "usages" => _openapi_value.usages) + _openapi_value.username isa Absent || push!(_openapi_output, "username" => _openapi_value.username) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequestCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lastupdatetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestCondition}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequestCondition, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequestCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequestCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_lastupdatetime = haskey(_openapi_object, "lastUpdateTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastUpdateTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCertificatesV1CertificateSigningRequestCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCertificatesV1CertificateSigningRequestCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","lastUpdateTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequestCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, lastupdatetime = _openapi_field_lastupdatetime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.lastupdatetime isa Absent || (_openapi_output["lastUpdateTime"] = _encode(_openapi_value.lastupdatetime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestCondition"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequestCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.lastupdatetime isa Absent || push!(_openapi_output, "lastUpdateTime" => _openapi_value.lastupdatetime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequestStatus + certificate::Union{Absent,Nothing,Vector{UInt8}} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCertificatesV1CertificateSigningRequestCondition}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestStatus}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequestStatus, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequestStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequestStatus") + _openapi_field_certificate = haskey(_openapi_object, "certificate") ? _decode(Union{Absent,Nothing,Vector{UInt8}}, _openapi_object["certificate"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCertificatesV1CertificateSigningRequestCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("certificate","conditions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequestStatus(; certificate = _openapi_field_certificate, conditions = _openapi_field_conditions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.certificate isa Absent || (_openapi_output["certificate"] = _encode(_openapi_value.certificate)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestStatus"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequestStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.certificate isa Absent || push!(_openapi_output, "certificate" => _openapi_value.certificate) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequest + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiCertificatesV1CertificateSigningRequestSpec + status::Union{Absent,IoK8sApiCertificatesV1CertificateSigningRequestStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequest}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequest, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequest}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequest"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequest") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiCertificatesV1CertificateSigningRequestSpec, _required(_openapi_object, "spec", "IoK8sApiCertificatesV1CertificateSigningRequest"), _openapi_validate) + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCertificatesV1CertificateSigningRequestStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequest(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequest) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequest"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequest"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequest) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCertificatesV1CertificateSigningRequestList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCertificatesV1CertificateSigningRequest}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestList}, value) = _decode(IoK8sApiCertificatesV1CertificateSigningRequestList, value, true) +function _decode(::Type{IoK8sApiCertificatesV1CertificateSigningRequestList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList"), _openapi_raw, "decoding IoK8sApiCertificatesV1CertificateSigningRequestList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCertificatesV1CertificateSigningRequestList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCertificatesV1CertificateSigningRequest}}, _required(_openapi_object, "items", "IoK8sApiCertificatesV1CertificateSigningRequestList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCertificatesV1CertificateSigningRequestList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.api.certificates.v1.CertificateSigningRequestList"), _openapi_output, "encoding IoK8sApiCertificatesV1CertificateSigningRequestList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCertificatesV1CertificateSigningRequestList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getcertificatesv1apiresources = ( + id = "getCertificatesV1APIResources", + method = "GET", + path = "/apis/certificates.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getcertificatesv1apiresources(...)\n\nget available resources\n\n`GET /apis/certificates.k8s.io/v1/`" +function getcertificatesv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getcertificatesv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecertificatesv1collectioncertificatesigningrequest = ( + id = "deleteCertificatesV1CollectionCertificateSigningRequest", + method = "DELETE", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecertificatesv1collectioncertificatesigningrequest(...)\n\ndelete collection of CertificateSigningRequest\n\n`DELETE /apis/certificates.k8s.io/v1/certificatesigningrequests`" +function deletecertificatesv1collectioncertificatesigningrequest(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecertificatesv1collectioncertificatesigningrequest, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcertificatesv1certificatesigningrequest = ( + id = "listCertificatesV1CertificateSigningRequest", + method = "GET", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequestList, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcertificatesv1certificatesigningrequest(...)\n\nlist or watch objects of kind CertificateSigningRequest\n\n`GET /apis/certificates.k8s.io/v1/certificatesigningrequests`" +function listcertificatesv1certificatesigningrequest(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcertificatesv1certificatesigningrequest, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcertificatesv1certificatesigningrequest = ( + id = "createCertificatesV1CertificateSigningRequest", + method = "POST", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcertificatesv1certificatesigningrequest(...)\n\ncreate a CertificateSigningRequest\n\n`POST /apis/certificates.k8s.io/v1/certificatesigningrequests`" +function createcertificatesv1certificatesigningrequest(body::IoK8sApiCertificatesV1CertificateSigningRequest; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcertificatesv1certificatesigningrequest, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecertificatesv1certificatesigningrequest = ( + id = "deleteCertificatesV1CertificateSigningRequest", + method = "DELETE", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecertificatesv1certificatesigningrequest(...)\n\ndelete a CertificateSigningRequest\n\n`DELETE /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}`" +function deletecertificatesv1certificatesigningrequest(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecertificatesv1certificatesigningrequest, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcertificatesv1certificatesigningrequest = ( + id = "readCertificatesV1CertificateSigningRequest", + method = "GET", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcertificatesv1certificatesigningrequest(...)\n\nread the specified CertificateSigningRequest\n\n`GET /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}`" +function readcertificatesv1certificatesigningrequest(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcertificatesv1certificatesigningrequest, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcertificatesv1certificatesigningrequest = ( + id = "patchCertificatesV1CertificateSigningRequest", + method = "PATCH", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcertificatesv1certificatesigningrequest(...)\n\npartially update the specified CertificateSigningRequest\n\n`PATCH /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}`" +function patchcertificatesv1certificatesigningrequest(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcertificatesv1certificatesigningrequest, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecertificatesv1certificatesigningrequest = ( + id = "replaceCertificatesV1CertificateSigningRequest", + method = "PUT", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecertificatesv1certificatesigningrequest(...)\n\nreplace the specified CertificateSigningRequest\n\n`PUT /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}`" +function replacecertificatesv1certificatesigningrequest(name::String, body::IoK8sApiCertificatesV1CertificateSigningRequest; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecertificatesv1certificatesigningrequest, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcertificatesv1certificatesigningrequestapproval = ( + id = "readCertificatesV1CertificateSigningRequestApproval", + method = "GET", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcertificatesv1certificatesigningrequestapproval(...)\n\nread approval of the specified CertificateSigningRequest\n\n`GET /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval`" +function readcertificatesv1certificatesigningrequestapproval(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcertificatesv1certificatesigningrequestapproval, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcertificatesv1certificatesigningrequestapproval = ( + id = "patchCertificatesV1CertificateSigningRequestApproval", + method = "PATCH", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcertificatesv1certificatesigningrequestapproval(...)\n\npartially update approval of the specified CertificateSigningRequest\n\n`PATCH /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval`" +function patchcertificatesv1certificatesigningrequestapproval(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcertificatesv1certificatesigningrequestapproval, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecertificatesv1certificatesigningrequestapproval = ( + id = "replaceCertificatesV1CertificateSigningRequestApproval", + method = "PUT", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1approval/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecertificatesv1certificatesigningrequestapproval(...)\n\nreplace approval of the specified CertificateSigningRequest\n\n`PUT /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval`" +function replacecertificatesv1certificatesigningrequestapproval(name::String, body::IoK8sApiCertificatesV1CertificateSigningRequest; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecertificatesv1certificatesigningrequestapproval, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcertificatesv1certificatesigningrequeststatus = ( + id = "readCertificatesV1CertificateSigningRequestStatus", + method = "GET", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcertificatesv1certificatesigningrequeststatus(...)\n\nread status of the specified CertificateSigningRequest\n\n`GET /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status`" +function readcertificatesv1certificatesigningrequeststatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcertificatesv1certificatesigningrequeststatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcertificatesv1certificatesigningrequeststatus = ( + id = "patchCertificatesV1CertificateSigningRequestStatus", + method = "PATCH", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcertificatesv1certificatesigningrequeststatus(...)\n\npartially update status of the specified CertificateSigningRequest\n\n`PATCH /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status`" +function patchcertificatesv1certificatesigningrequeststatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcertificatesv1certificatesigningrequeststatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecertificatesv1certificatesigningrequeststatus = ( + id = "replaceCertificatesV1CertificateSigningRequestStatus", + method = "PUT", + path = "/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCertificatesV1CertificateSigningRequest, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1certificatesigningrequests~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecertificatesv1certificatesigningrequeststatus(...)\n\nreplace status of the specified CertificateSigningRequest\n\n`PUT /apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status`" +function replacecertificatesv1certificatesigningrequeststatus(name::String, body::IoK8sApiCertificatesV1CertificateSigningRequest; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecertificatesv1certificatesigningrequeststatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcertificatesv1certificatesigningrequestlist = ( + id = "watchCertificatesV1CertificateSigningRequestList", + method = "GET", + path = "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcertificatesv1certificatesigningrequestlist(...)\n\nwatch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/certificates.k8s.io/v1/watch/certificatesigningrequests`" +function watchcertificatesv1certificatesigningrequestlist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcertificatesv1certificatesigningrequestlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcertificatesv1certificatesigningrequest = ( + id = "watchCertificatesV1CertificateSigningRequest", + method = "GET", + path = "/apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-19e697dd14a7543656fb.json", pointer = "/paths/~1apis~1certificates.k8s.io~1v1~1watch~1certificatesigningrequests~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcertificatesv1certificatesigningrequest(...)\n\nwatch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}`" +function watchcertificatesv1certificatesigningrequest(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcertificatesv1certificatesigningrequest, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sCertificatesK8sIoV1 diff --git a/src/ApiImpl/generated/K8sCoordinationK8sIoV1.jl b/src/ApiImpl/generated/K8sCoordinationK8sIoV1.jl new file mode 100644 index 00000000..b9a3a5e9 --- /dev/null +++ b/src/ApiImpl/generated/K8sCoordinationK8sIoV1.jl @@ -0,0 +1,1600 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sCoordinationK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", retrieval = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.coordination.v1.Lease\":{\"description\":\"Lease defines a lease concept.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseSpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}]},\"io.k8s.api.coordination.v1.LeaseList\":{\"description\":\"LeaseList is a list of Lease objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of schema objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"coordination.k8s.io\",\"kind\":\"LeaseList\",\"version\":\"v1\"}]},\"io.k8s.api.coordination.v1.LeaseSpec\":{\"description\":\"LeaseSpec is a specification of a Lease.\",\"properties\":{\"acquireTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"},\"holderIdentity\":{\"description\":\"holderIdentity contains the identity of the holder of a current lease. If Coordinated Leader Election is used, the holder identity must be equal to the elected LeaseCandidate.metadata.name field.\",\"type\":\"string\"},\"leaseDurationSeconds\":{\"description\":\"leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measured against the time of last observed renewTime.\",\"format\":\"int32\",\"type\":\"integer\"},\"leaseTransitions\":{\"description\":\"leaseTransitions is the number of transitions of a lease between holders.\",\"format\":\"int32\",\"type\":\"integer\"},\"preferredHolder\":{\"description\":\"PreferredHolder signals to a lease holder that the lease has a more optimal holder and should be given up. This field can only be set if Strategy is also set.\",\"type\":\"string\"},\"renewTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"},\"strategy\":{\"description\":\"Strategy indicates the strategy for picking the leader for coordinated leader election. If the field is not specified, there is no active coordination for this lease. (Alpha) Using this field requires the CoordinatedLeaderElection feature gate to be enabled.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\":{\"description\":\"MicroTime is version of Time with microsecond level precision.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/coordination.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getCoordinationV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"]}},\"/apis/coordination.k8s.io/v1/leases\":{\"get\":{\"description\":\"list or watch objects of kind Lease\",\"operationId\":\"listCoordinationV1LeaseForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases\":{\"delete\":{\"description\":\"delete collection of Lease\",\"operationId\":\"deleteCoordinationV1CollectionNamespacedLease\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Lease\",\"operationId\":\"listCoordinationV1NamespacedLease\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.LeaseList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Lease\",\"operationId\":\"createCoordinationV1NamespacedLease\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}}},\"/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}\":{\"delete\":{\"description\":\"delete a Lease\",\"operationId\":\"deleteCoordinationV1NamespacedLease\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Lease\",\"operationId\":\"readCoordinationV1NamespacedLease\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Lease\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Lease\",\"operationId\":\"patchCoordinationV1NamespacedLease\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Lease\",\"operationId\":\"replaceCoordinationV1NamespacedLease\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.api.coordination.v1.Lease\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}}},\"/apis/coordination.k8s.io/v1/watch/leases\":{\"get\":{\"description\":\"watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoordinationV1LeaseListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases\":{\"get\":{\"description\":\"watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoordinationV1NamespacedLeaseList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoordinationV1NamespacedLease\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"coordination_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"coordination.k8s.io\",\"kind\":\"Lease\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Lease\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.Lease", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1MicroTime = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApiCoordinationV1LeaseSpec + acquiretime::Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} = ABSENT + holderidentity::Union{Absent,Nothing,String} = ABSENT + leasedurationseconds::Union{Absent,Int32,Nothing} = ABSENT + leasetransitions::Union{Absent,Int32,Nothing} = ABSENT + preferredholder::Union{Absent,Nothing,String} = ABSENT + renewtime::Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} = ABSENT + strategy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoordinationV1LeaseSpec}, value) = _decode(IoK8sApiCoordinationV1LeaseSpec, value, true) +function _decode(::Type{IoK8sApiCoordinationV1LeaseSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseSpec"), _openapi_raw, "decoding IoK8sApiCoordinationV1LeaseSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoordinationV1LeaseSpec") + _openapi_field_acquiretime = haskey(_openapi_object, "acquireTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _openapi_object["acquireTime"], _openapi_validate) : ABSENT + _openapi_field_holderidentity = haskey(_openapi_object, "holderIdentity") ? _decode(Union{Absent,Nothing,String}, _openapi_object["holderIdentity"], _openapi_validate) : ABSENT + _openapi_field_leasedurationseconds = haskey(_openapi_object, "leaseDurationSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["leaseDurationSeconds"], _openapi_validate) : ABSENT + _openapi_field_leasetransitions = haskey(_openapi_object, "leaseTransitions") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["leaseTransitions"], _openapi_validate) : ABSENT + _openapi_field_preferredholder = haskey(_openapi_object, "preferredHolder") ? _decode(Union{Absent,Nothing,String}, _openapi_object["preferredHolder"], _openapi_validate) : ABSENT + _openapi_field_renewtime = haskey(_openapi_object, "renewTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _openapi_object["renewTime"], _openapi_validate) : ABSENT + _openapi_field_strategy = haskey(_openapi_object, "strategy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["strategy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("acquireTime","holderIdentity","leaseDurationSeconds","leaseTransitions","preferredHolder","renewTime","strategy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoordinationV1LeaseSpec(; acquiretime = _openapi_field_acquiretime, holderidentity = _openapi_field_holderidentity, leasedurationseconds = _openapi_field_leasedurationseconds, leasetransitions = _openapi_field_leasetransitions, preferredholder = _openapi_field_preferredholder, renewtime = _openapi_field_renewtime, strategy = _openapi_field_strategy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoordinationV1LeaseSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.acquiretime isa Absent || (_openapi_output["acquireTime"] = _encode(_openapi_value.acquiretime)) + _openapi_value.holderidentity isa Absent || (_openapi_output["holderIdentity"] = _encode(_openapi_value.holderidentity)) + _openapi_value.leasedurationseconds isa Absent || (_openapi_output["leaseDurationSeconds"] = _encode(_openapi_value.leasedurationseconds)) + _openapi_value.leasetransitions isa Absent || (_openapi_output["leaseTransitions"] = _encode(_openapi_value.leasetransitions)) + _openapi_value.preferredholder isa Absent || (_openapi_output["preferredHolder"] = _encode(_openapi_value.preferredholder)) + _openapi_value.renewtime isa Absent || (_openapi_output["renewTime"] = _encode(_openapi_value.renewtime)) + _openapi_value.strategy isa Absent || (_openapi_output["strategy"] = _encode(_openapi_value.strategy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseSpec"), _openapi_output, "encoding IoK8sApiCoordinationV1LeaseSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoordinationV1LeaseSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.acquiretime isa Absent || push!(_openapi_output, "acquireTime" => _openapi_value.acquiretime) + _openapi_value.holderidentity isa Absent || push!(_openapi_output, "holderIdentity" => _openapi_value.holderidentity) + _openapi_value.leasedurationseconds isa Absent || push!(_openapi_output, "leaseDurationSeconds" => _openapi_value.leasedurationseconds) + _openapi_value.leasetransitions isa Absent || push!(_openapi_output, "leaseTransitions" => _openapi_value.leasetransitions) + _openapi_value.preferredholder isa Absent || push!(_openapi_output, "preferredHolder" => _openapi_value.preferredholder) + _openapi_value.renewtime isa Absent || push!(_openapi_output, "renewTime" => _openapi_value.renewtime) + _openapi_value.strategy isa Absent || push!(_openapi_output, "strategy" => _openapi_value.strategy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoordinationV1Lease + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoordinationV1LeaseSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoordinationV1Lease}, value) = _decode(IoK8sApiCoordinationV1Lease, value, true) +function _decode(::Type{IoK8sApiCoordinationV1Lease}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.Lease"), _openapi_raw, "decoding IoK8sApiCoordinationV1Lease"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoordinationV1Lease") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoordinationV1LeaseSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoordinationV1Lease(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoordinationV1Lease) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.Lease"), _openapi_output, "encoding IoK8sApiCoordinationV1Lease"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoordinationV1Lease) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoordinationV1LeaseList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoordinationV1Lease}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoordinationV1LeaseList}, value) = _decode(IoK8sApiCoordinationV1LeaseList, value, true) +function _decode(::Type{IoK8sApiCoordinationV1LeaseList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseList"), _openapi_raw, "decoding IoK8sApiCoordinationV1LeaseList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoordinationV1LeaseList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoordinationV1Lease}}, _required(_openapi_object, "items", "IoK8sApiCoordinationV1LeaseList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoordinationV1LeaseList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoordinationV1LeaseList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.api.coordination.v1.LeaseList"), _openapi_output, "encoding IoK8sApiCoordinationV1LeaseList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoordinationV1LeaseList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getcoordinationv1apiresources = ( + id = "getCoordinationV1APIResources", + method = "GET", + path = "/apis/coordination.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getcoordinationv1apiresources(...)\n\nget available resources\n\n`GET /apis/coordination.k8s.io/v1/`" +function getcoordinationv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getcoordinationv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcoordinationv1leaseforallnamespaces = ( + id = "listCoordinationV1LeaseForAllNamespaces", + method = "GET", + path = "/apis/coordination.k8s.io/v1/leases", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1leases/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcoordinationv1leaseforallnamespaces(...)\n\nlist or watch objects of kind Lease\n\n`GET /apis/coordination.k8s.io/v1/leases`" +function listcoordinationv1leaseforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcoordinationv1leaseforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecoordinationv1collectionnamespacedlease = ( + id = "deleteCoordinationV1CollectionNamespacedLease", + method = "DELETE", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecoordinationv1collectionnamespacedlease(...)\n\ndelete collection of Lease\n\n`DELETE /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases`" +function deletecoordinationv1collectionnamespacedlease(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecoordinationv1collectionnamespacedlease, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcoordinationv1namespacedlease = ( + id = "listCoordinationV1NamespacedLease", + method = "GET", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1LeaseList, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcoordinationv1namespacedlease(...)\n\nlist or watch objects of kind Lease\n\n`GET /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases`" +function listcoordinationv1namespacedlease(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcoordinationv1namespacedlease, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcoordinationv1namespacedlease = ( + id = "createCoordinationV1NamespacedLease", + method = "POST", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcoordinationv1namespacedlease(...)\n\ncreate a Lease\n\n`POST /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases`" +function createcoordinationv1namespacedlease(namespace::String, body::IoK8sApiCoordinationV1Lease; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcoordinationv1namespacedlease, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecoordinationv1namespacedlease = ( + id = "deleteCoordinationV1NamespacedLease", + method = "DELETE", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecoordinationv1namespacedlease(...)\n\ndelete a Lease\n\n`DELETE /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}`" +function deletecoordinationv1namespacedlease(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecoordinationv1namespacedlease, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcoordinationv1namespacedlease = ( + id = "readCoordinationV1NamespacedLease", + method = "GET", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcoordinationv1namespacedlease(...)\n\nread the specified Lease\n\n`GET /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}`" +function readcoordinationv1namespacedlease(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcoordinationv1namespacedlease, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcoordinationv1namespacedlease = ( + id = "patchCoordinationV1NamespacedLease", + method = "PATCH", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcoordinationv1namespacedlease(...)\n\npartially update the specified Lease\n\n`PATCH /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}`" +function patchcoordinationv1namespacedlease(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcoordinationv1namespacedlease, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecoordinationv1namespacedlease = ( + id = "replaceCoordinationV1NamespacedLease", + method = "PUT", + path = "/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoordinationV1Lease, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1namespaces~1{namespace}~1leases~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecoordinationv1namespacedlease(...)\n\nreplace the specified Lease\n\n`PUT /apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}`" +function replacecoordinationv1namespacedlease(namespace::String, name::String, body::IoK8sApiCoordinationV1Lease; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecoordinationv1namespacedlease, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcoordinationv1leaselistforallnamespaces = ( + id = "watchCoordinationV1LeaseListForAllNamespaces", + method = "GET", + path = "/apis/coordination.k8s.io/v1/watch/leases", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1leases/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcoordinationv1leaselistforallnamespaces(...)\n\nwatch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/coordination.k8s.io/v1/watch/leases`" +function watchcoordinationv1leaselistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcoordinationv1leaselistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcoordinationv1namespacedleaselist = ( + id = "watchCoordinationV1NamespacedLeaseList", + method = "GET", + path = "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcoordinationv1namespacedleaselist(...)\n\nwatch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases`" +function watchcoordinationv1namespacedleaselist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcoordinationv1namespacedleaselist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcoordinationv1namespacedlease = ( + id = "watchCoordinationV1NamespacedLease", + method = "GET", + path = "/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-0e7ad1fbf3aa094c4671.json", pointer = "/paths/~1apis~1coordination.k8s.io~1v1~1watch~1namespaces~1{namespace}~1leases~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcoordinationv1namespacedlease(...)\n\nwatch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}`" +function watchcoordinationv1namespacedlease(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcoordinationv1namespacedlease, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sCoordinationK8sIoV1 diff --git a/src/ApiImpl/generated/K8sDiscoveryK8sIoV1.jl b/src/ApiImpl/generated/K8sDiscoveryK8sIoV1.jl new file mode 100644 index 00000000..5f1ca16e --- /dev/null +++ b/src/ApiImpl/generated/K8sDiscoveryK8sIoV1.jl @@ -0,0 +1,1890 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sDiscoveryK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", retrieval = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.core.v1.ObjectReference\":{\"description\":\"ObjectReference contains enough information to let you inspect or modify the referred object.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"fieldPath\":{\"description\":\"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \\\"spec.containers{name}\\\" (where \\\"name\\\" refers to the name of the container that triggered the event) or if no container name is specified \\\"spec.containers[2]\\\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.discovery.v1.Endpoint\":{\"description\":\"Endpoint represents a single logical \\\"backend\\\" implementing a service.\",\"properties\":{\"addresses\":{\"description\":\"addresses of this endpoint. For EndpointSlices of addressType \\\"IPv4\\\" or \\\"IPv6\\\", the values are IP addresses in canonical form. The syntax and semantics of other addressType values are not defined. This must contain at least one address but no more than 100. EndpointSlices generated by the EndpointSlice controller will always have exactly 1 address. No semantics are defined for additional addresses beyond the first, and kube-proxy does not look at them.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true},\"conditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointConditions\"},\"deprecatedTopology\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"deprecatedTopology contains topology information part of the v1beta1 API. This field is deprecated, and will be removed when the v1beta1 API is removed (no sooner than kubernetes v1.24). While this field can hold values, it is not writable through the v1 API, and any attempts to write to it will be silently ignored. Topology information can be found in the zone and nodeName fields instead.\",\"type\":\"object\"},\"hints\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointHints\"},\"hostname\":{\"description\":\"hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must be lowercase and pass DNS Label (RFC 1123) validation.\",\"type\":\"string\"},\"nodeName\":{\"description\":\"nodeName represents the name of the Node hosting this endpoint. This can be used to determine endpoints local to a Node.\",\"type\":\"string\"},\"targetRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"zone\":{\"description\":\"zone is the name of the Zone this endpoint exists in.\",\"type\":\"string\"}},\"required\":[\"addresses\"],\"type\":\"object\"},\"io.k8s.api.discovery.v1.EndpointConditions\":{\"description\":\"EndpointConditions represents the current condition of an endpoint.\",\"properties\":{\"ready\":{\"description\":\"ready indicates that this endpoint is ready to receive traffic, according to whatever system is managing the endpoint. A nil value should be interpreted as \\\"true\\\". In general, an endpoint should be marked ready if it is serving and not terminating, though this can be overridden in some cases, such as when the associated Service has set the publishNotReadyAddresses flag.\",\"type\":\"boolean\"},\"serving\":{\"description\":\"serving indicates that this endpoint is able to receive traffic, according to whatever system is managing the endpoint. For endpoints backed by pods, the EndpointSlice controller will mark the endpoint as serving if the pod's Ready condition is True. A nil value should be interpreted as \\\"true\\\".\",\"type\":\"boolean\"},\"terminating\":{\"description\":\"terminating indicates that this endpoint is terminating. A nil value should be interpreted as \\\"false\\\".\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.discovery.v1.EndpointHints\":{\"description\":\"EndpointHints provides hints describing how an endpoint should be consumed.\",\"properties\":{\"forNodes\":{\"description\":\"forNodes indicates the node(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.ForNode\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"forZones\":{\"description\":\"forZones indicates the zone(s) this endpoint should be consumed by when using topology aware routing. May contain a maximum of 8 entries.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.ForZone\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.discovery.v1.EndpointPort\":{\"description\":\"EndpointPort represents a Port used by an EndpointSlice\",\"properties\":{\"appProtocol\":{\"description\":\"The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\\n\\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\\n\\n* Kubernetes-defined prefixed names:\\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\\n\\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.\",\"type\":\"string\"},\"name\":{\"description\":\"name represents the name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is derived from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string.\",\"type\":\"string\"},\"port\":{\"description\":\"port represents the port number of the endpoint. If the EndpointSlice is derived from a Kubernetes service, this must be set to the service's target port. EndpointSlices used for other purposes may have a nil port.\",\"format\":\"int32\",\"type\":\"integer\"},\"protocol\":{\"description\":\"protocol represents the IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.discovery.v1.EndpointSlice\":{\"description\":\"EndpointSlice represents a set of service endpoints. Most EndpointSlices are created by the EndpointSlice controller to represent the Pods selected by Service objects. For a given service there may be multiple EndpointSlice objects which must be joined to produce the full set of endpoints; you can find all of the slices for a given service by listing EndpointSlices in the service's namespace whose `kubernetes.io/service-name` label contains the service's name.\",\"properties\":{\"addressType\":{\"default\":\"\",\"description\":\"addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. (Deprecated) The EndpointSlice controller only generates, and kube-proxy only processes, slices of addressType \\\"IPv4\\\" and \\\"IPv6\\\". No semantics are defined for the \\\"FQDN\\\" type.\",\"type\":\"string\"},\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"endpoints\":{\"description\":\"endpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.Endpoint\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"ports\":{\"description\":\"ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. Each slice may include a maximum of 100 ports. Services always have at least 1 port, so EndpointSlices generated by the EndpointSlice controller will likewise always have at least 1 port. EndpointSlices used for other purposes may have an empty ports list.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"addressType\",\"endpoints\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}]},\"io.k8s.api.discovery.v1.EndpointSliceList\":{\"description\":\"EndpointSliceList represents a list of endpoint slices\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of endpoint slices\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSliceList\",\"version\":\"v1\"}]},\"io.k8s.api.discovery.v1.ForNode\":{\"description\":\"ForNode provides information about which nodes should consume this endpoint.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name represents the name of the node.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.discovery.v1.ForZone\":{\"description\":\"ForZone provides information about which zones should consume this endpoint.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name represents the name of the zone.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/discovery.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getDiscoveryV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"]}},\"/apis/discovery.k8s.io/v1/endpointslices\":{\"get\":{\"description\":\"list or watch objects of kind EndpointSlice\",\"operationId\":\"listDiscoveryV1EndpointSliceForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices\":{\"delete\":{\"description\":\"delete collection of EndpointSlice\",\"operationId\":\"deleteDiscoveryV1CollectionNamespacedEndpointSlice\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind EndpointSlice\",\"operationId\":\"listDiscoveryV1NamespacedEndpointSlice\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an EndpointSlice\",\"operationId\":\"createDiscoveryV1NamespacedEndpointSlice\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}}},\"/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}\":{\"delete\":{\"description\":\"delete an EndpointSlice\",\"operationId\":\"deleteDiscoveryV1NamespacedEndpointSlice\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified EndpointSlice\",\"operationId\":\"readDiscoveryV1NamespacedEndpointSlice\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the EndpointSlice\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified EndpointSlice\",\"operationId\":\"patchDiscoveryV1NamespacedEndpointSlice\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified EndpointSlice\",\"operationId\":\"replaceDiscoveryV1NamespacedEndpointSlice\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.api.discovery.v1.EndpointSlice\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}}},\"/apis/discovery.k8s.io/v1/watch/endpointslices\":{\"get\":{\"description\":\"watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchDiscoveryV1EndpointSliceListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices\":{\"get\":{\"description\":\"watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchDiscoveryV1NamespacedEndpointSliceList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchDiscoveryV1NamespacedEndpointSlice\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"discovery_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"discovery.k8s.io\",\"kind\":\"EndpointSlice\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the EndpointSlice\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.Endpoint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointConditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointHints", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSlice", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForNode", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForZone", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiCoreV1ObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectReference}, value) = _decode(IoK8sApiCoreV1ObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath","kind","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectReference(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointConditions + ready::Union{Absent,Bool,Nothing} = ABSENT + serving::Union{Absent,Bool,Nothing} = ABSENT + terminating::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointConditions}, value) = _decode(IoK8sApiDiscoveryV1EndpointConditions, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointConditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointConditions"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointConditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointConditions") + _openapi_field_ready = haskey(_openapi_object, "ready") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ready"], _openapi_validate) : ABSENT + _openapi_field_serving = haskey(_openapi_object, "serving") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["serving"], _openapi_validate) : ABSENT + _openapi_field_terminating = haskey(_openapi_object, "terminating") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["terminating"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ready","serving","terminating") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointConditions(; ready = _openapi_field_ready, serving = _openapi_field_serving, terminating = _openapi_field_terminating, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointConditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ready isa Absent || (_openapi_output["ready"] = _encode(_openapi_value.ready)) + _openapi_value.serving isa Absent || (_openapi_output["serving"] = _encode(_openapi_value.serving)) + _openapi_value.terminating isa Absent || (_openapi_output["terminating"] = _encode(_openapi_value.terminating)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointConditions"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointConditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointConditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.ready isa Absent || push!(_openapi_output, "ready" => _openapi_value.ready) + _openapi_value.serving isa Absent || push!(_openapi_output, "serving" => _openapi_value.serving) + _openapi_value.terminating isa Absent || push!(_openapi_output, "terminating" => _openapi_value.terminating) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointDeprecatedTopology + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointDeprecatedTopology}, value) = _decode(IoK8sApiDiscoveryV1EndpointDeprecatedTopology, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointDeprecatedTopology}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.Endpoint/properties/deprecatedTopology"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointDeprecatedTopology"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointDeprecatedTopology") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointDeprecatedTopology(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointDeprecatedTopology) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.Endpoint/properties/deprecatedTopology"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointDeprecatedTopology"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointDeprecatedTopology) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1ForNode + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1ForNode}, value) = _decode(IoK8sApiDiscoveryV1ForNode, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1ForNode}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForNode"), _openapi_raw, "decoding IoK8sApiDiscoveryV1ForNode"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1ForNode") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiDiscoveryV1ForNode"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1ForNode(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1ForNode) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForNode"), _openapi_output, "encoding IoK8sApiDiscoveryV1ForNode"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1ForNode) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1ForZone + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1ForZone}, value) = _decode(IoK8sApiDiscoveryV1ForZone, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1ForZone}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForZone"), _openapi_raw, "decoding IoK8sApiDiscoveryV1ForZone"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1ForZone") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiDiscoveryV1ForZone"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1ForZone(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1ForZone) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.ForZone"), _openapi_output, "encoding IoK8sApiDiscoveryV1ForZone"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1ForZone) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointHints + fornodes::Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1ForNode}}} = ABSENT + forzones::Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1ForZone}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointHints}, value) = _decode(IoK8sApiDiscoveryV1EndpointHints, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointHints}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointHints"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointHints"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointHints") + _openapi_field_fornodes = haskey(_openapi_object, "forNodes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1ForNode}}}, _openapi_object["forNodes"], _openapi_validate) : ABSENT + _openapi_field_forzones = haskey(_openapi_object, "forZones") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1ForZone}}}, _openapi_object["forZones"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("forNodes","forZones") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointHints(; fornodes = _openapi_field_fornodes, forzones = _openapi_field_forzones, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointHints) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fornodes isa Absent || (_openapi_output["forNodes"] = _encode(_openapi_value.fornodes)) + _openapi_value.forzones isa Absent || (_openapi_output["forZones"] = _encode(_openapi_value.forzones)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointHints"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointHints"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointHints) + _openapi_output = Pair{String,Any}[] + _openapi_value.fornodes isa Absent || push!(_openapi_output, "forNodes" => _openapi_value.fornodes) + _openapi_value.forzones isa Absent || push!(_openapi_output, "forZones" => _openapi_value.forzones) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1Endpoint + addresses::Union{Nothing,Vector{String}} + conditions::Union{Absent,IoK8sApiDiscoveryV1EndpointConditions,Nothing} = ABSENT + deprecatedtopology::Union{Absent,IoK8sApiDiscoveryV1EndpointDeprecatedTopology,Nothing} = ABSENT + hints::Union{Absent,IoK8sApiDiscoveryV1EndpointHints,Nothing} = ABSENT + hostname::Union{Absent,Nothing,String} = ABSENT + nodename::Union{Absent,Nothing,String} = ABSENT + targetref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + zone::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1Endpoint}, value) = _decode(IoK8sApiDiscoveryV1Endpoint, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1Endpoint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.Endpoint"), _openapi_raw, "decoding IoK8sApiDiscoveryV1Endpoint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1Endpoint") + _openapi_field_addresses = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "addresses", "IoK8sApiDiscoveryV1Endpoint"), _openapi_validate) + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,IoK8sApiDiscoveryV1EndpointConditions,Nothing}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_deprecatedtopology = haskey(_openapi_object, "deprecatedTopology") ? _decode(Union{Absent,IoK8sApiDiscoveryV1EndpointDeprecatedTopology,Nothing}, _openapi_object["deprecatedTopology"], _openapi_validate) : ABSENT + _openapi_field_hints = haskey(_openapi_object, "hints") ? _decode(Union{Absent,IoK8sApiDiscoveryV1EndpointHints,Nothing}, _openapi_object["hints"], _openapi_validate) : ABSENT + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_nodename = haskey(_openapi_object, "nodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeName"], _openapi_validate) : ABSENT + _openapi_field_targetref = haskey(_openapi_object, "targetRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["targetRef"], _openapi_validate) : ABSENT + _openapi_field_zone = haskey(_openapi_object, "zone") ? _decode(Union{Absent,Nothing,String}, _openapi_object["zone"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("addresses","conditions","deprecatedTopology","hints","hostname","nodeName","targetRef","zone") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1Endpoint(; addresses = _openapi_field_addresses, conditions = _openapi_field_conditions, deprecatedtopology = _openapi_field_deprecatedtopology, hints = _openapi_field_hints, hostname = _openapi_field_hostname, nodename = _openapi_field_nodename, targetref = _openapi_field_targetref, zone = _openapi_field_zone, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1Endpoint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.addresses isa Absent || (_openapi_output["addresses"] = _encode(_openapi_value.addresses)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.deprecatedtopology isa Absent || (_openapi_output["deprecatedTopology"] = _encode(_openapi_value.deprecatedtopology)) + _openapi_value.hints isa Absent || (_openapi_output["hints"] = _encode(_openapi_value.hints)) + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.targetref isa Absent || (_openapi_output["targetRef"] = _encode(_openapi_value.targetref)) + _openapi_value.zone isa Absent || (_openapi_output["zone"] = _encode(_openapi_value.zone)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.Endpoint"), _openapi_output, "encoding IoK8sApiDiscoveryV1Endpoint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1Endpoint) + _openapi_output = Pair{String,Any}[] + _openapi_value.addresses isa Absent || push!(_openapi_output, "addresses" => _openapi_value.addresses) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.deprecatedtopology isa Absent || push!(_openapi_output, "deprecatedTopology" => _openapi_value.deprecatedtopology) + _openapi_value.hints isa Absent || push!(_openapi_output, "hints" => _openapi_value.hints) + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.targetref isa Absent || push!(_openapi_output, "targetRef" => _openapi_value.targetref) + _openapi_value.zone isa Absent || push!(_openapi_output, "zone" => _openapi_value.zone) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointPort + appprotocol::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + port::Union{Absent,Int32,Nothing} = ABSENT + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointPort}, value) = _decode(IoK8sApiDiscoveryV1EndpointPort, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointPort"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointPort") + _openapi_field_appprotocol = haskey(_openapi_object, "appProtocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["appProtocol"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_port = haskey(_openapi_object, "port") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["port"], _openapi_validate) : ABSENT + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appProtocol","name","port","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointPort(; appprotocol = _openapi_field_appprotocol, name = _openapi_field_name, port = _openapi_field_port, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.appprotocol isa Absent || (_openapi_output["appProtocol"] = _encode(_openapi_value.appprotocol)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointPort"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.appprotocol isa Absent || push!(_openapi_output, "appProtocol" => _openapi_value.appprotocol) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointSlice + addresstype::String + apiversion::Union{Absent,Nothing,String} = ABSENT + endpoints::Union{Nothing,Vector{IoK8sApiDiscoveryV1Endpoint}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1EndpointPort}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointSlice}, value) = _decode(IoK8sApiDiscoveryV1EndpointSlice, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointSlice}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSlice"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointSlice"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointSlice") + _openapi_field_addresstype = _decode(String, _required(_openapi_object, "addressType", "IoK8sApiDiscoveryV1EndpointSlice"), _openapi_validate) + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_endpoints = _decode(Union{Nothing,Vector{IoK8sApiDiscoveryV1Endpoint}}, _required(_openapi_object, "endpoints", "IoK8sApiDiscoveryV1EndpointSlice"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiDiscoveryV1EndpointPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("addressType","apiVersion","endpoints","kind","metadata","ports") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointSlice(; addresstype = _openapi_field_addresstype, apiversion = _openapi_field_apiversion, endpoints = _openapi_field_endpoints, kind = _openapi_field_kind, metadata = _openapi_field_metadata, ports = _openapi_field_ports, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointSlice) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.addresstype isa Absent || (_openapi_output["addressType"] = _encode(_openapi_value.addresstype)) + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSlice"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointSlice"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointSlice) + _openapi_output = Pair{String,Any}[] + _openapi_value.addresstype isa Absent || push!(_openapi_output, "addressType" => _openapi_value.addresstype) + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiDiscoveryV1EndpointSliceList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiDiscoveryV1EndpointSlice}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiDiscoveryV1EndpointSliceList}, value) = _decode(IoK8sApiDiscoveryV1EndpointSliceList, value, true) +function _decode(::Type{IoK8sApiDiscoveryV1EndpointSliceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList"), _openapi_raw, "decoding IoK8sApiDiscoveryV1EndpointSliceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiDiscoveryV1EndpointSliceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiDiscoveryV1EndpointSlice}}, _required(_openapi_object, "items", "IoK8sApiDiscoveryV1EndpointSliceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiDiscoveryV1EndpointSliceList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiDiscoveryV1EndpointSliceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.api.discovery.v1.EndpointSliceList"), _openapi_output, "encoding IoK8sApiDiscoveryV1EndpointSliceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiDiscoveryV1EndpointSliceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getdiscoveryv1apiresources = ( + id = "getDiscoveryV1APIResources", + method = "GET", + path = "/apis/discovery.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getdiscoveryv1apiresources(...)\n\nget available resources\n\n`GET /apis/discovery.k8s.io/v1/`" +function getdiscoveryv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getdiscoveryv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listdiscoveryv1endpointsliceforallnamespaces = ( + id = "listDiscoveryV1EndpointSliceForAllNamespaces", + method = "GET", + path = "/apis/discovery.k8s.io/v1/endpointslices", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1endpointslices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listdiscoveryv1endpointsliceforallnamespaces(...)\n\nlist or watch objects of kind EndpointSlice\n\n`GET /apis/discovery.k8s.io/v1/endpointslices`" +function listdiscoveryv1endpointsliceforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listdiscoveryv1endpointsliceforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletediscoveryv1collectionnamespacedendpointslice = ( + id = "deleteDiscoveryV1CollectionNamespacedEndpointSlice", + method = "DELETE", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletediscoveryv1collectionnamespacedendpointslice(...)\n\ndelete collection of EndpointSlice\n\n`DELETE /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices`" +function deletediscoveryv1collectionnamespacedendpointslice(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletediscoveryv1collectionnamespacedendpointslice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listdiscoveryv1namespacedendpointslice = ( + id = "listDiscoveryV1NamespacedEndpointSlice", + method = "GET", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSliceList, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listdiscoveryv1namespacedendpointslice(...)\n\nlist or watch objects of kind EndpointSlice\n\n`GET /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices`" +function listdiscoveryv1namespacedendpointslice(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listdiscoveryv1namespacedendpointslice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_creatediscoveryv1namespacedendpointslice = ( + id = "createDiscoveryV1NamespacedEndpointSlice", + method = "POST", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " creatediscoveryv1namespacedendpointslice(...)\n\ncreate an EndpointSlice\n\n`POST /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices`" +function creatediscoveryv1namespacedendpointslice(namespace::String, body::IoK8sApiDiscoveryV1EndpointSlice; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_creatediscoveryv1namespacedendpointslice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletediscoveryv1namespacedendpointslice = ( + id = "deleteDiscoveryV1NamespacedEndpointSlice", + method = "DELETE", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletediscoveryv1namespacedendpointslice(...)\n\ndelete an EndpointSlice\n\n`DELETE /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}`" +function deletediscoveryv1namespacedendpointslice(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletediscoveryv1namespacedendpointslice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readdiscoveryv1namespacedendpointslice = ( + id = "readDiscoveryV1NamespacedEndpointSlice", + method = "GET", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readdiscoveryv1namespacedendpointslice(...)\n\nread the specified EndpointSlice\n\n`GET /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}`" +function readdiscoveryv1namespacedendpointslice(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readdiscoveryv1namespacedendpointslice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchdiscoveryv1namespacedendpointslice = ( + id = "patchDiscoveryV1NamespacedEndpointSlice", + method = "PATCH", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchdiscoveryv1namespacedendpointslice(...)\n\npartially update the specified EndpointSlice\n\n`PATCH /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}`" +function patchdiscoveryv1namespacedendpointslice(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchdiscoveryv1namespacedendpointslice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacediscoveryv1namespacedendpointslice = ( + id = "replaceDiscoveryV1NamespacedEndpointSlice", + method = "PUT", + path = "/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiDiscoveryV1EndpointSlice, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1namespaces~1{namespace}~1endpointslices~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacediscoveryv1namespacedendpointslice(...)\n\nreplace the specified EndpointSlice\n\n`PUT /apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}`" +function replacediscoveryv1namespacedendpointslice(namespace::String, name::String, body::IoK8sApiDiscoveryV1EndpointSlice; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacediscoveryv1namespacedendpointslice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchdiscoveryv1endpointslicelistforallnamespaces = ( + id = "watchDiscoveryV1EndpointSliceListForAllNamespaces", + method = "GET", + path = "/apis/discovery.k8s.io/v1/watch/endpointslices", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1endpointslices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchdiscoveryv1endpointslicelistforallnamespaces(...)\n\nwatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/discovery.k8s.io/v1/watch/endpointslices`" +function watchdiscoveryv1endpointslicelistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchdiscoveryv1endpointslicelistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchdiscoveryv1namespacedendpointslicelist = ( + id = "watchDiscoveryV1NamespacedEndpointSliceList", + method = "GET", + path = "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchdiscoveryv1namespacedendpointslicelist(...)\n\nwatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices`" +function watchdiscoveryv1namespacedendpointslicelist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchdiscoveryv1namespacedendpointslicelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchdiscoveryv1namespacedendpointslice = ( + id = "watchDiscoveryV1NamespacedEndpointSlice", + method = "GET", + path = "/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-960bcd0a076bc1c28214.json", pointer = "/paths/~1apis~1discovery.k8s.io~1v1~1watch~1namespaces~1{namespace}~1endpointslices~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchdiscoveryv1namespacedendpointslice(...)\n\nwatch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}`" +function watchdiscoveryv1namespacedendpointslice(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchdiscoveryv1namespacedendpointslice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sDiscoveryK8sIoV1 diff --git a/src/ApiImpl/generated/K8sEventsK8sIoV1.jl b/src/ApiImpl/generated/K8sEventsK8sIoV1.jl new file mode 100644 index 00000000..c85763c8 --- /dev/null +++ b/src/ApiImpl/generated/K8sEventsK8sIoV1.jl @@ -0,0 +1,1728 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sEventsK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", retrieval = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.core.v1.EventSource\":{\"description\":\"EventSource contains information for an event.\",\"properties\":{\"component\":{\"description\":\"Component from which the event is generated.\",\"type\":\"string\"},\"host\":{\"description\":\"Node name on which the event is generated.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ObjectReference\":{\"description\":\"ObjectReference contains enough information to let you inspect or modify the referred object.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"fieldPath\":{\"description\":\"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \\\"spec.containers{name}\\\" (where \\\"name\\\" refers to the name of the container that triggered the event) or if no container name is specified \\\"spec.containers[2]\\\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.events.v1.Event\":{\"description\":\"Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.\",\"properties\":{\"action\":{\"description\":\"action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters.\",\"type\":\"string\"},\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"deprecatedCount\":{\"description\":\"deprecatedCount is the deprecated field assuring backward compatibility with core.v1 Event type.\",\"format\":\"int32\",\"type\":\"integer\"},\"deprecatedFirstTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deprecatedLastTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deprecatedSource\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.core.v1.EventSource\"},\"eventTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"note\":{\"description\":\"note is a human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB.\",\"type\":\"string\"},\"reason\":{\"description\":\"reason is why the action was taken. It is human-readable. This field cannot be empty for new Events and it can have at most 128 characters.\",\"type\":\"string\"},\"regarding\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"related\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"reportingController\":{\"description\":\"reportingController is the name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. This field cannot be empty for new Events.\",\"type\":\"string\"},\"reportingInstance\":{\"description\":\"reportingInstance is the ID of the controller instance, e.g. `kubelet-xyzf`. This field cannot be empty for new Events and it can have at most 128 characters.\",\"type\":\"string\"},\"series\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventSeries\"},\"type\":{\"description\":\"type is the type of this event (Normal, Warning), new types could be added in the future. It is machine-readable. This field cannot be empty for new Events.\",\"type\":\"string\"}},\"required\":[\"eventTime\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}]},\"io.k8s.api.events.v1.EventList\":{\"description\":\"EventList is a list of Event objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of schema objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"events.k8s.io\",\"kind\":\"EventList\",\"version\":\"v1\"}]},\"io.k8s.api.events.v1.EventSeries\":{\"description\":\"EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in \\\"k8s.io/client-go/tools/events/event_broadcaster.go\\\" shows how this struct is updated on heartbeats and can guide customized reporter implementations.\",\"properties\":{\"count\":{\"default\":0,\"description\":\"count is the number of occurrences in this series up to the last heartbeat time.\",\"format\":\"int32\",\"type\":\"integer\"},\"lastObservedTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"}},\"required\":[\"count\",\"lastObservedTime\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\":{\"description\":\"MicroTime is version of Time with microsecond level precision.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/events.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getEventsV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"]}},\"/apis/events.k8s.io/v1/events\":{\"get\":{\"description\":\"list or watch objects of kind Event\",\"operationId\":\"listEventsV1EventForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/events.k8s.io/v1/namespaces/{namespace}/events\":{\"delete\":{\"description\":\"delete collection of Event\",\"operationId\":\"deleteEventsV1CollectionNamespacedEvent\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Event\",\"operationId\":\"listEventsV1NamespacedEvent\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.EventList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an Event\",\"operationId\":\"createEventsV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}}},\"/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}\":{\"delete\":{\"description\":\"delete an Event\",\"operationId\":\"deleteEventsV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Event\",\"operationId\":\"readEventsV1NamespacedEvent\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Event\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Event\",\"operationId\":\"patchEventsV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Event\",\"operationId\":\"replaceEventsV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.api.events.v1.Event\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}}},\"/apis/events.k8s.io/v1/watch/events\":{\"get\":{\"description\":\"watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchEventsV1EventListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events\":{\"get\":{\"description\":\"watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchEventsV1NamespacedEventList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchEventsV1NamespacedEvent\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"events_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"events.k8s.io\",\"kind\":\"Event\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Event\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.Event", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventSeries", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiCoreV1EventSource + component::Union{Absent,Nothing,String} = ABSENT + host::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EventSource}, value) = _decode(IoK8sApiCoreV1EventSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EventSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource"), _openapi_raw, "decoding IoK8sApiCoreV1EventSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EventSource") + _openapi_field_component = haskey(_openapi_object, "component") ? _decode(Union{Absent,Nothing,String}, _openapi_object["component"], _openapi_validate) : ABSENT + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("component","host") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EventSource(; component = _openapi_field_component, host = _openapi_field_host, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EventSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.component isa Absent || (_openapi_output["component"] = _encode(_openapi_value.component)) + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource"), _openapi_output, "encoding IoK8sApiCoreV1EventSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EventSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.component isa Absent || push!(_openapi_output, "component" => _openapi_value.component) + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectReference}, value) = _decode(IoK8sApiCoreV1ObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath","kind","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectReference(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +const IoK8sApimachineryPkgApisMetaV1MicroTime = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiEventsV1EventSeries + count::Int32 + lastobservedtime::Union{IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiEventsV1EventSeries}, value) = _decode(IoK8sApiEventsV1EventSeries, value, true) +function _decode(::Type{IoK8sApiEventsV1EventSeries}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventSeries"), _openapi_raw, "decoding IoK8sApiEventsV1EventSeries"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiEventsV1EventSeries") + _openapi_field_count = _decode(Int32, _required(_openapi_object, "count", "IoK8sApiEventsV1EventSeries"), _openapi_validate) + _openapi_field_lastobservedtime = _decode(Union{IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _required(_openapi_object, "lastObservedTime", "IoK8sApiEventsV1EventSeries"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("count","lastObservedTime") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiEventsV1EventSeries(; count = _openapi_field_count, lastobservedtime = _openapi_field_lastobservedtime, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiEventsV1EventSeries) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.count isa Absent || (_openapi_output["count"] = _encode(_openapi_value.count)) + _openapi_value.lastobservedtime isa Absent || (_openapi_output["lastObservedTime"] = _encode(_openapi_value.lastobservedtime)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventSeries"), _openapi_output, "encoding IoK8sApiEventsV1EventSeries"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiEventsV1EventSeries) + _openapi_output = Pair{String,Any}[] + _openapi_value.count isa Absent || push!(_openapi_output, "count" => _openapi_value.count) + _openapi_value.lastobservedtime isa Absent || push!(_openapi_output, "lastObservedTime" => _openapi_value.lastobservedtime) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiEventsV1Event + action::Union{Absent,Nothing,String} = ABSENT + apiversion::Union{Absent,Nothing,String} = ABSENT + deprecatedcount::Union{Absent,Int32,Nothing} = ABSENT + deprecatedfirsttimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deprecatedlasttimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deprecatedsource::Union{Absent,IoK8sApiCoreV1EventSource,Nothing} = ABSENT + eventtime::Union{IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + note::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + regarding::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + related::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + reportingcontroller::Union{Absent,Nothing,String} = ABSENT + reportinginstance::Union{Absent,Nothing,String} = ABSENT + series::Union{Absent,IoK8sApiEventsV1EventSeries,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiEventsV1Event}, value) = _decode(IoK8sApiEventsV1Event, value, true) +function _decode(::Type{IoK8sApiEventsV1Event}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.Event"), _openapi_raw, "decoding IoK8sApiEventsV1Event"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiEventsV1Event") + _openapi_field_action = haskey(_openapi_object, "action") ? _decode(Union{Absent,Nothing,String}, _openapi_object["action"], _openapi_validate) : ABSENT + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_deprecatedcount = haskey(_openapi_object, "deprecatedCount") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["deprecatedCount"], _openapi_validate) : ABSENT + _openapi_field_deprecatedfirsttimestamp = haskey(_openapi_object, "deprecatedFirstTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deprecatedFirstTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deprecatedlasttimestamp = haskey(_openapi_object, "deprecatedLastTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deprecatedLastTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deprecatedsource = haskey(_openapi_object, "deprecatedSource") ? _decode(Union{Absent,IoK8sApiCoreV1EventSource,Nothing}, _openapi_object["deprecatedSource"], _openapi_validate) : ABSENT + _openapi_field_eventtime = _decode(Union{IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _required(_openapi_object, "eventTime", "IoK8sApiEventsV1Event"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_note = haskey(_openapi_object, "note") ? _decode(Union{Absent,Nothing,String}, _openapi_object["note"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_regarding = haskey(_openapi_object, "regarding") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["regarding"], _openapi_validate) : ABSENT + _openapi_field_related = haskey(_openapi_object, "related") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["related"], _openapi_validate) : ABSENT + _openapi_field_reportingcontroller = haskey(_openapi_object, "reportingController") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reportingController"], _openapi_validate) : ABSENT + _openapi_field_reportinginstance = haskey(_openapi_object, "reportingInstance") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reportingInstance"], _openapi_validate) : ABSENT + _openapi_field_series = haskey(_openapi_object, "series") ? _decode(Union{Absent,IoK8sApiEventsV1EventSeries,Nothing}, _openapi_object["series"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","apiVersion","deprecatedCount","deprecatedFirstTimestamp","deprecatedLastTimestamp","deprecatedSource","eventTime","kind","metadata","note","reason","regarding","related","reportingController","reportingInstance","series","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiEventsV1Event(; action = _openapi_field_action, apiversion = _openapi_field_apiversion, deprecatedcount = _openapi_field_deprecatedcount, deprecatedfirsttimestamp = _openapi_field_deprecatedfirsttimestamp, deprecatedlasttimestamp = _openapi_field_deprecatedlasttimestamp, deprecatedsource = _openapi_field_deprecatedsource, eventtime = _openapi_field_eventtime, kind = _openapi_field_kind, metadata = _openapi_field_metadata, note = _openapi_field_note, reason = _openapi_field_reason, regarding = _openapi_field_regarding, related = _openapi_field_related, reportingcontroller = _openapi_field_reportingcontroller, reportinginstance = _openapi_field_reportinginstance, series = _openapi_field_series, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiEventsV1Event) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.deprecatedcount isa Absent || (_openapi_output["deprecatedCount"] = _encode(_openapi_value.deprecatedcount)) + _openapi_value.deprecatedfirsttimestamp isa Absent || (_openapi_output["deprecatedFirstTimestamp"] = _encode(_openapi_value.deprecatedfirsttimestamp)) + _openapi_value.deprecatedlasttimestamp isa Absent || (_openapi_output["deprecatedLastTimestamp"] = _encode(_openapi_value.deprecatedlasttimestamp)) + _openapi_value.deprecatedsource isa Absent || (_openapi_output["deprecatedSource"] = _encode(_openapi_value.deprecatedsource)) + _openapi_value.eventtime isa Absent || (_openapi_output["eventTime"] = _encode(_openapi_value.eventtime)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.note isa Absent || (_openapi_output["note"] = _encode(_openapi_value.note)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.regarding isa Absent || (_openapi_output["regarding"] = _encode(_openapi_value.regarding)) + _openapi_value.related isa Absent || (_openapi_output["related"] = _encode(_openapi_value.related)) + _openapi_value.reportingcontroller isa Absent || (_openapi_output["reportingController"] = _encode(_openapi_value.reportingcontroller)) + _openapi_value.reportinginstance isa Absent || (_openapi_output["reportingInstance"] = _encode(_openapi_value.reportinginstance)) + _openapi_value.series isa Absent || (_openapi_output["series"] = _encode(_openapi_value.series)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.Event"), _openapi_output, "encoding IoK8sApiEventsV1Event"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiEventsV1Event) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.deprecatedcount isa Absent || push!(_openapi_output, "deprecatedCount" => _openapi_value.deprecatedcount) + _openapi_value.deprecatedfirsttimestamp isa Absent || push!(_openapi_output, "deprecatedFirstTimestamp" => _openapi_value.deprecatedfirsttimestamp) + _openapi_value.deprecatedlasttimestamp isa Absent || push!(_openapi_output, "deprecatedLastTimestamp" => _openapi_value.deprecatedlasttimestamp) + _openapi_value.deprecatedsource isa Absent || push!(_openapi_output, "deprecatedSource" => _openapi_value.deprecatedsource) + _openapi_value.eventtime isa Absent || push!(_openapi_output, "eventTime" => _openapi_value.eventtime) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.note isa Absent || push!(_openapi_output, "note" => _openapi_value.note) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.regarding isa Absent || push!(_openapi_output, "regarding" => _openapi_value.regarding) + _openapi_value.related isa Absent || push!(_openapi_output, "related" => _openapi_value.related) + _openapi_value.reportingcontroller isa Absent || push!(_openapi_output, "reportingController" => _openapi_value.reportingcontroller) + _openapi_value.reportinginstance isa Absent || push!(_openapi_output, "reportingInstance" => _openapi_value.reportinginstance) + _openapi_value.series isa Absent || push!(_openapi_output, "series" => _openapi_value.series) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiEventsV1EventList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiEventsV1Event}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiEventsV1EventList}, value) = _decode(IoK8sApiEventsV1EventList, value, true) +function _decode(::Type{IoK8sApiEventsV1EventList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventList"), _openapi_raw, "decoding IoK8sApiEventsV1EventList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiEventsV1EventList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiEventsV1Event}}, _required(_openapi_object, "items", "IoK8sApiEventsV1EventList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiEventsV1EventList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiEventsV1EventList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.api.events.v1.EventList"), _openapi_output, "encoding IoK8sApiEventsV1EventList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiEventsV1EventList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_geteventsv1apiresources = ( + id = "getEventsV1APIResources", + method = "GET", + path = "/apis/events.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " geteventsv1apiresources(...)\n\nget available resources\n\n`GET /apis/events.k8s.io/v1/`" +function geteventsv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_geteventsv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listeventsv1eventforallnamespaces = ( + id = "listEventsV1EventForAllNamespaces", + method = "GET", + path = "/apis/events.k8s.io/v1/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listeventsv1eventforallnamespaces(...)\n\nlist or watch objects of kind Event\n\n`GET /apis/events.k8s.io/v1/events`" +function listeventsv1eventforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listeventsv1eventforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteeventsv1collectionnamespacedevent = ( + id = "deleteEventsV1CollectionNamespacedEvent", + method = "DELETE", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteeventsv1collectionnamespacedevent(...)\n\ndelete collection of Event\n\n`DELETE /apis/events.k8s.io/v1/namespaces/{namespace}/events`" +function deleteeventsv1collectionnamespacedevent(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteeventsv1collectionnamespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listeventsv1namespacedevent = ( + id = "listEventsV1NamespacedEvent", + method = "GET", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiEventsV1EventList, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listeventsv1namespacedevent(...)\n\nlist or watch objects of kind Event\n\n`GET /apis/events.k8s.io/v1/namespaces/{namespace}/events`" +function listeventsv1namespacedevent(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listeventsv1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createeventsv1namespacedevent = ( + id = "createEventsV1NamespacedEvent", + method = "POST", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createeventsv1namespacedevent(...)\n\ncreate an Event\n\n`POST /apis/events.k8s.io/v1/namespaces/{namespace}/events`" +function createeventsv1namespacedevent(namespace::String, body::IoK8sApiEventsV1Event; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createeventsv1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteeventsv1namespacedevent = ( + id = "deleteEventsV1NamespacedEvent", + method = "DELETE", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteeventsv1namespacedevent(...)\n\ndelete an Event\n\n`DELETE /apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}`" +function deleteeventsv1namespacedevent(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteeventsv1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readeventsv1namespacedevent = ( + id = "readEventsV1NamespacedEvent", + method = "GET", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readeventsv1namespacedevent(...)\n\nread the specified Event\n\n`GET /apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}`" +function readeventsv1namespacedevent(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readeventsv1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patcheventsv1namespacedevent = ( + id = "patchEventsV1NamespacedEvent", + method = "PATCH", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patcheventsv1namespacedevent(...)\n\npartially update the specified Event\n\n`PATCH /apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}`" +function patcheventsv1namespacedevent(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patcheventsv1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceeventsv1namespacedevent = ( + id = "replaceEventsV1NamespacedEvent", + method = "PUT", + path = "/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiEventsV1Event, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceeventsv1namespacedevent(...)\n\nreplace the specified Event\n\n`PUT /apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}`" +function replaceeventsv1namespacedevent(namespace::String, name::String, body::IoK8sApiEventsV1Event; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceeventsv1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watcheventsv1eventlistforallnamespaces = ( + id = "watchEventsV1EventListForAllNamespaces", + method = "GET", + path = "/apis/events.k8s.io/v1/watch/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watcheventsv1eventlistforallnamespaces(...)\n\nwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/events.k8s.io/v1/watch/events`" +function watcheventsv1eventlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watcheventsv1eventlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watcheventsv1namespacedeventlist = ( + id = "watchEventsV1NamespacedEventList", + method = "GET", + path = "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watcheventsv1namespacedeventlist(...)\n\nwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/events.k8s.io/v1/watch/namespaces/{namespace}/events`" +function watcheventsv1namespacedeventlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watcheventsv1namespacedeventlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watcheventsv1namespacedevent = ( + id = "watchEventsV1NamespacedEvent", + method = "GET", + path = "/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a8c72a2dde8a7e0f66c2.json", pointer = "/paths/~1apis~1events.k8s.io~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watcheventsv1namespacedevent(...)\n\nwatch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}`" +function watcheventsv1namespacedevent(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watcheventsv1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sEventsK8sIoV1 diff --git a/src/ApiImpl/generated/K8sMetricsK8sIoV1beta1.jl b/src/ApiImpl/generated/K8sMetricsK8sIoV1beta1.jl new file mode 100644 index 00000000..55f2a952 --- /dev/null +++ b/src/ApiImpl/generated/K8sMetricsK8sIoV1beta1.jl @@ -0,0 +1,1133 @@ +# Generated by OpenAPI.jl from "Kubernetes metrics-server" version "v0.8.1". Do not edit. +module K8sMetricsK8sIoV1beta1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", retrieval = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", media_type = "application/openapi+json", json = "{\"openapi\":\"3.0.0\",\"info\":{\"title\":\"Kubernetes metrics-server\",\"version\":\"v0.8.1\"},\"paths\":{\"/apis/metrics.k8s.io/v1beta1/\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"get available resources\",\"operationId\":\"getMetricsV1beta1APIResources\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}}}}}},\"/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"list objects of kind PodMetrics\",\"operationId\":\"listMetricsV1beta1NamespacedPodMetrics\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}}}}},\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"metrics.k8s.io\",\"version\":\"v1beta1\",\"kind\":\"PodMetrics\"}},\"parameters\":[{\"name\":\"allowWatchBookmarks\",\"in\":\"query\",\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"continue\",\"in\":\"query\",\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"fieldSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"labelSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"limit\",\"in\":\"query\",\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"namespace\",\"in\":\"path\",\"description\":\"object name and auth scope, such as for teams and projects\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"pretty\",\"in\":\"query\",\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersion\",\"in\":\"query\",\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersionMatch\",\"in\":\"query\",\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"sendInitialEvents\",\"in\":\"query\",\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"timeoutSeconds\",\"in\":\"query\",\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"watch\",\"in\":\"query\",\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"read the specified PodMetrics\",\"operationId\":\"readMetricsV1beta1NamespacedPodMetrics\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics\"}}}}},\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"metrics.k8s.io\",\"version\":\"v1beta1\",\"kind\":\"PodMetrics\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"name\":\"name\",\"in\":\"path\",\"description\":\"name of the PodMetrics\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"namespace\",\"in\":\"path\",\"description\":\"object name and auth scope, such as for teams and projects\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"pretty\",\"in\":\"query\",\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"/apis/metrics.k8s.io/v1beta1/nodes\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"list objects of kind NodeMetrics\",\"operationId\":\"listMetricsV1beta1NodeMetrics\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\"}}}}},\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"metrics.k8s.io\",\"version\":\"v1beta1\",\"kind\":\"NodeMetrics\"}},\"parameters\":[{\"name\":\"allowWatchBookmarks\",\"in\":\"query\",\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"continue\",\"in\":\"query\",\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"fieldSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"labelSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"limit\",\"in\":\"query\",\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"pretty\",\"in\":\"query\",\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersion\",\"in\":\"query\",\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersionMatch\",\"in\":\"query\",\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"sendInitialEvents\",\"in\":\"query\",\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"timeoutSeconds\",\"in\":\"query\",\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"watch\",\"in\":\"query\",\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/metrics.k8s.io/v1beta1/nodes/{name}\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"read the specified NodeMetrics\",\"operationId\":\"readMetricsV1beta1NodeMetrics\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics\"}}}}},\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"metrics.k8s.io\",\"version\":\"v1beta1\",\"kind\":\"NodeMetrics\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"name\":\"name\",\"in\":\"path\",\"description\":\"name of the NodeMetrics\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"pretty\",\"in\":\"query\",\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"/apis/metrics.k8s.io/v1beta1/pods\":{\"get\":{\"tags\":[\"metrics_v1beta1\"],\"description\":\"list objects of kind PodMetrics\",\"operationId\":\"listMetricsV1beta1PodMetricsForAllNamespaces\",\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\"}}}}},\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"metrics.k8s.io\",\"version\":\"v1beta1\",\"kind\":\"PodMetrics\"}},\"parameters\":[{\"name\":\"allowWatchBookmarks\",\"in\":\"query\",\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"continue\",\"in\":\"query\",\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"fieldSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"labelSelector\",\"in\":\"query\",\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"limit\",\"in\":\"query\",\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"pretty\",\"in\":\"query\",\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersion\",\"in\":\"query\",\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"resourceVersionMatch\",\"in\":\"query\",\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"name\":\"sendInitialEvents\",\"in\":\"query\",\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"name\":\"timeoutSeconds\",\"in\":\"query\",\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"name\":\"watch\",\"in\":\"query\",\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}},\"components\":{\"schemas\":{\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"type\":\"object\",\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"type\":[\"array\",\"null\"],\"items\":{\"type\":\"string\",\"default\":\"\"},\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\",\"default\":\"\"},\"name\":{\"description\":\"name is the plural name of the resource.\",\"type\":\"string\",\"default\":\"\"},\"namespaced\":{\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\",\"default\":false},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"type\":[\"array\",\"null\"],\"items\":{\"type\":\"string\",\"default\":\"\"},\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\",\"default\":\"\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"type\":[\"array\",\"null\"],\"items\":{\"type\":\"string\",\"default\":\"\"},\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}}},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"type\":\"object\",\"required\":[\"groupVersion\",\"resources\"],\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\",\"default\":\"\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.Duration\":{\"description\":\"Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json.\",\"type\":\"string\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"type\":\"object\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"type\":\"integer\",\"format\":\"int64\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}}},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"type\":\"object\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}}},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"type\":\"object\",\"properties\":{\"annotations\":{\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\",\"additionalProperties\":{\"type\":\"string\",\"default\":\"\"}},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"type\":\"integer\",\"format\":\"int64\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"type\":[\"array\",\"null\"],\"items\":{\"type\":\"string\",\"default\":\"\"},\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"type\":\"integer\",\"format\":\"int64\"},\"labels\":{\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\",\"additionalProperties\":{\"type\":\"string\",\"default\":\"\"}},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}}},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"type\":\"object\",\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\",\"default\":\"\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\",\"default\":\"\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\",\"default\":\"\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\",\"default\":\"\"}},\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"type\":[\"string\",\"null\"],\"format\":\"date-time\",\"nullable\":true},\"io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics\":{\"description\":\"ContainerMetrics sets resource usage metrics of a container.\",\"type\":\"object\",\"required\":[\"name\",\"usage\"],\"properties\":{\"name\":{\"description\":\"Container name corresponding to the one from pod.spec.containers.\",\"type\":\"string\",\"default\":\"\"},\"usage\":{\"description\":\"The memory usage is the memory working set.\",\"type\":\"object\",\"additionalProperties\":{\"default\":{},\"allOf\":[{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}]}}}},\"io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics\":{\"description\":\"NodeMetrics sets resource usage metrics of a node.\",\"type\":\"object\",\"required\":[\"timestamp\",\"window\",\"usage\"],\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"timestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"usage\":{\"description\":\"The memory usage is the memory working set.\",\"type\":\"object\",\"additionalProperties\":{\"default\":{},\"allOf\":[{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}]}},\"window\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration\"}},\"x-kubernetes-group-version-kind\":[{\"group\":\"metrics.k8s.io\",\"kind\":\"NodeMetrics\",\"version\":\"v1beta1\"}]},\"io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList\":{\"description\":\"NodeMetricsList is a list of NodeMetrics.\",\"type\":\"object\",\"required\":[\"items\"],\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of node metrics.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics\"},\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"x-kubernetes-group-version-kind\":[{\"group\":\"metrics.k8s.io\",\"kind\":\"NodeMetricsList\",\"version\":\"v1beta1\"}]},\"io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics\":{\"description\":\"PodMetrics sets resource usage metrics of a pod.\",\"type\":\"object\",\"required\":[\"timestamp\",\"window\",\"containers\"],\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"containers\":{\"description\":\"Metrics for all containers are collected within the same time window.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics\"},\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"timestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"window\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration\"}},\"x-kubernetes-group-version-kind\":[{\"group\":\"metrics.k8s.io\",\"kind\":\"PodMetrics\",\"version\":\"v1beta1\"}]},\"io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList\":{\"description\":\"PodMetricsList is a list of PodMetrics.\",\"type\":\"object\",\"required\":[\"items\"],\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of pod metrics.\",\"type\":[\"array\",\"null\"],\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics\"},\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-40cf6d446f55535733ba.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"x-kubernetes-group-version-kind\":[{\"group\":\"metrics.k8s.io\",\"kind\":\"PodMetricsList\",\"version\":\"v1beta1\"}]}}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Duration", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Duration = String + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1 + value::Union{Float64,String} +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics/properties/usage/additionalProperties"), value, "decoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1")) + return IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1(first(matches)) +end +function _encode(value::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics/properties/usage/additionalProperties"), output, "encoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1"; direction = :neutral) +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage + additional_properties::Dict{String,IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1} = Dict{String,IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics/properties/usage"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage") + _openapi_additional_properties = Dict{String,IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsageAdditionalValue1, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics/properties/usage"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics + name::String + usage::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics"), _openapi_validate) + _openapi_field_usage = _decode(IoK8sMetricsPkgApisMetricsV1beta1ContainerMetricsUsage, _required(_openapi_object, "usage", "IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","usage") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics(; name = _openapi_field_name, usage = _openapi_field_usage, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.usage isa Absent || (_openapi_output["usage"] = _encode(_openapi_value.usage)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.usage isa Absent || push!(_openapi_output, "usage" => _openapi_value.usage) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1 + value::Union{Float64,String} +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics/properties/usage/additionalProperties"), value, "decoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1")) + return IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1(first(matches)) +end +function _encode(value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics/properties/usage/additionalProperties"), output, "encoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1"; direction = :neutral) +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage + additional_properties::Dict{String,IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1} = Dict{String,IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics/properties/usage"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage") + _openapi_additional_properties = Dict{String,IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsageAdditionalValue1, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics/properties/usage"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + timestamp::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + usage::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage + window::IoK8sApimachineryPkgApisMetaV1Duration + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_timestamp = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "timestamp", "IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics"), _openapi_validate) + _openapi_field_usage = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsUsage, _required(_openapi_object, "usage", "IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics"), _openapi_validate) + _openapi_field_window = _decode(IoK8sApimachineryPkgApisMetaV1Duration, _required(_openapi_object, "window", "IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","timestamp","usage","window") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, timestamp = _openapi_field_timestamp, usage = _openapi_field_usage, window = _openapi_field_window, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.timestamp isa Absent || (_openapi_output["timestamp"] = _encode(_openapi_value.timestamp)) + _openapi_value.usage isa Absent || (_openapi_output["usage"] = _encode(_openapi_value.usage)) + _openapi_value.window isa Absent || (_openapi_output["window"] = _encode(_openapi_value.window)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetrics"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.timestamp isa Absent || push!(_openapi_output, "timestamp" => _openapi_value.timestamp) + _openapi_value.usage isa Absent || push!(_openapi_output, "usage" => _openapi_value.usage) + _openapi_value.window isa Absent || push!(_openapi_output, "window" => _openapi_value.window) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics}}, _required(_openapi_object, "items", "IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsList"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1PodMetrics + apiversion::Union{Absent,Nothing,String} = ABSENT + containers::Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + timestamp::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + window::IoK8sApimachineryPkgApisMetaV1Duration + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1PodMetrics}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1PodMetrics, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1PodMetrics}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1PodMetrics"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1PodMetrics") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_containers = _decode(Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1ContainerMetrics}}, _required(_openapi_object, "containers", "IoK8sMetricsPkgApisMetricsV1beta1PodMetrics"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_timestamp = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "timestamp", "IoK8sMetricsPkgApisMetricsV1beta1PodMetrics"), _openapi_validate) + _openapi_field_window = _decode(IoK8sApimachineryPkgApisMetaV1Duration, _required(_openapi_object, "window", "IoK8sMetricsPkgApisMetricsV1beta1PodMetrics"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","containers","kind","metadata","timestamp","window") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1PodMetrics(; apiversion = _openapi_field_apiversion, containers = _openapi_field_containers, kind = _openapi_field_kind, metadata = _openapi_field_metadata, timestamp = _openapi_field_timestamp, window = _openapi_field_window, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1PodMetrics) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.containers isa Absent || (_openapi_output["containers"] = _encode(_openapi_value.containers)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.timestamp isa Absent || (_openapi_output["timestamp"] = _encode(_openapi_value.timestamp)) + _openapi_value.window isa Absent || (_openapi_output["window"] = _encode(_openapi_value.window)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1PodMetrics"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1PodMetrics) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.containers isa Absent || push!(_openapi_output, "containers" => _openapi_value.containers) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.timestamp isa Absent || push!(_openapi_output, "timestamp" => _openapi_value.timestamp) + _openapi_value.window isa Absent || push!(_openapi_output, "window" => _openapi_value.window) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1PodMetrics}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList}, value) = _decode(IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, value, true) +function _decode(::Type{IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList"), _openapi_raw, "decoding IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sMetricsPkgApisMetricsV1beta1PodMetrics}}, _required(_openapi_object, "items", "IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/components/schemas/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList"), _openapi_output, "encoding IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getmetricsv1beta1apiresources = ( + id = "getMetricsV1beta1APIResources", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getmetricsv1beta1apiresources(...)\n\nget available resources\n\n`GET /apis/metrics.k8s.io/v1beta1/`" +function getmetricsv1beta1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getmetricsv1beta1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listmetricsv1beta1namespacedpodmetrics = ( + id = "listMetricsV1beta1NamespacedPodMetrics", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listmetricsv1beta1namespacedpodmetrics(...)\n\nlist objects of kind PodMetrics\n\n`GET /apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods`" +function listmetricsv1beta1namespacedpodmetrics(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listmetricsv1beta1namespacedpodmetrics, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readmetricsv1beta1namespacedpodmetrics = ( + id = "readMetricsV1beta1NamespacedPodMetrics", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sMetricsPkgApisMetricsV1beta1PodMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sMetricsPkgApisMetricsV1beta1PodMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sMetricsPkgApisMetricsV1beta1PodMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readmetricsv1beta1namespacedpodmetrics(...)\n\nread the specified PodMetrics\n\n`GET /apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name}`" +function readmetricsv1beta1namespacedpodmetrics(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readmetricsv1beta1namespacedpodmetrics, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listmetricsv1beta1nodemetrics = ( + id = "listMetricsV1beta1NodeMetrics", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/nodes", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listmetricsv1beta1nodemetrics(...)\n\nlist objects of kind NodeMetrics\n\n`GET /apis/metrics.k8s.io/v1beta1/nodes`" +function listmetricsv1beta1nodemetrics(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listmetricsv1beta1nodemetrics, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readmetricsv1beta1nodemetrics = ( + id = "readMetricsV1beta1NodeMetrics", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/nodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1nodes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readmetricsv1beta1nodemetrics(...)\n\nread the specified NodeMetrics\n\n`GET /apis/metrics.k8s.io/v1beta1/nodes/{name}`" +function readmetricsv1beta1nodemetrics(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readmetricsv1beta1nodemetrics, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listmetricsv1beta1podmetricsforallnamespaces = ( + id = "listMetricsV1beta1PodMetricsForAllNamespaces", + method = "GET", + path = "/apis/metrics.k8s.io/v1beta1/pods", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/json", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, (resource = "https://openapi.invalid/schema/root-40cf6d446f55535733ba.json", pointer = "/paths/~1apis~1metrics.k8s.io~1v1beta1~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listmetricsv1beta1podmetricsforallnamespaces(...)\n\nlist objects of kind PodMetrics\n\n`GET /apis/metrics.k8s.io/v1beta1/pods`" +function listmetricsv1beta1podmetricsforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listmetricsv1beta1podmetricsforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sMetricsK8sIoV1beta1 diff --git a/src/ApiImpl/generated/K8sNetworkingK8sIoV1.jl b/src/ApiImpl/generated/K8sNetworkingK8sIoV1.jl new file mode 100644 index 00000000..66349ece --- /dev/null +++ b/src/ApiImpl/generated/K8sNetworkingK8sIoV1.jl @@ -0,0 +1,5017 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sNetworkingK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", retrieval = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.core.v1.TypedLocalObjectReference\":{\"description\":\"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.networking.v1.HTTPIngressPath\":{\"description\":\"HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend.\",\"properties\":{\"backend\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressBackend\"},\"path\":{\"description\":\"path is matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \\\"path\\\" part of a URL as defined by RFC 3986. Paths must begin with a '/' and must be present when using PathType with value \\\"Exact\\\" or \\\"Prefix\\\".\",\"type\":\"string\"},\"pathType\":{\"description\":\"pathType determines the interpretation of the path matching. PathType can be one of the following values: * Exact: Matches the URL path exactly. * Prefix: Matches based on a URL path prefix split by '/'. Matching is\\n done on a path element by element basis. A path element refers is the\\n list of labels in the path split by the '/' separator. A request is a\\n match for path p if every p is an element-wise prefix of p of the\\n request path. Note that if the last element of the path is a substring\\n of the last element in request path, it is not a match (e.g. /foo/bar\\n matches /foo/bar/baz, but does not match /foo/barbaz).\\n* ImplementationSpecific: Interpretation of the Path matching is up to\\n the IngressClass. Implementations can treat this as a separate PathType\\n or treat it identically to Prefix or Exact path types.\\nImplementations are required to support all path types.\",\"type\":\"string\"}},\"required\":[\"pathType\",\"backend\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.HTTPIngressRuleValue\":{\"description\":\"HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'.\",\"properties\":{\"paths\":{\"description\":\"paths is a collection of paths that map requests to backends.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"paths\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.IPAddress\":{\"description\":\"IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressSpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IPAddressList\":{\"description\":\"IPAddressList contains a list of IPAddress.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of IPAddresses.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddressList\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IPAddressSpec\":{\"description\":\"IPAddressSpec describe the attributes in an IP Address.\",\"properties\":{\"parentRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ParentReference\"}},\"required\":[\"parentRef\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.IPBlock\":{\"description\":\"IPBlock describes a particular CIDR (Ex. \\\"192.168.1.0/24\\\",\\\"2001:db8::/64\\\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.\",\"properties\":{\"cidr\":{\"default\":\"\",\"description\":\"cidr is a string representing the IPBlock Valid examples are \\\"192.168.1.0/24\\\" or \\\"2001:db8::/64\\\"\",\"type\":\"string\"},\"except\":{\"description\":\"except is a slice of CIDRs that should not be included within an IPBlock Valid examples are \\\"192.168.1.0/24\\\" or \\\"2001:db8::/64\\\" Except values will be rejected if they are outside the cidr range\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"cidr\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.Ingress\":{\"description\":\"Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IngressBackend\":{\"description\":\"IngressBackend describes all endpoints for a given service and port.\",\"properties\":{\"resource\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference\"},\"service\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressClass\":{\"description\":\"IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassSpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IngressClassList\":{\"description\":\"IngressClassList is a collection of IngressClasses.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of IngressClasses.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClassList\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IngressClassParametersReference\":{\"description\":\"IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource.\",\"properties\":{\"apiGroup\":{\"description\":\"apiGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the type of resource being referenced.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the name of resource being referenced.\",\"type\":\"string\"},\"namespace\":{\"description\":\"namespace is the namespace of the resource being referenced. This field is required when scope is set to \\\"Namespace\\\" and must be unset when scope is set to \\\"Cluster\\\".\",\"type\":\"string\"},\"scope\":{\"description\":\"scope represents if this refers to a cluster or namespace scoped resource. This may be set to \\\"Cluster\\\" (default) or \\\"Namespace\\\".\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressClassSpec\":{\"description\":\"IngressClassSpec provides information about the class of an Ingress.\",\"properties\":{\"controller\":{\"description\":\"controller refers to the name of the controller that should handle this class. This allows for different \\\"flavors\\\" that are controlled by the same controller. For example, you may have different parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. \\\"acme.io/ingress-controller\\\". This field is immutable.\",\"type\":\"string\"},\"parameters\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressList\":{\"description\":\"IngressList is a collection of Ingress.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of Ingress.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"IngressList\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.IngressLoadBalancerIngress\":{\"description\":\"IngressLoadBalancerIngress represents the status of a load-balancer ingress point.\",\"properties\":{\"hostname\":{\"description\":\"hostname is set for load-balancer ingress points that are DNS based.\",\"type\":\"string\"},\"ip\":{\"description\":\"ip is set for load-balancer ingress points that are IP based.\",\"type\":\"string\"},\"ports\":{\"description\":\"ports provides information about the ports exposed by this LoadBalancer.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressPortStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressLoadBalancerStatus\":{\"description\":\"IngressLoadBalancerStatus represents the status of a load-balancer.\",\"properties\":{\"ingress\":{\"description\":\"ingress is a list containing ingress points for the load-balancer.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressPortStatus\":{\"description\":\"IngressPortStatus represents the error condition of a service port\",\"properties\":{\"error\":{\"description\":\"error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\\n CamelCase names\\n- cloud provider specific error values must have names that comply with the\\n format foo.example.com/CamelCase.\",\"type\":\"string\"},\"port\":{\"default\":0,\"description\":\"port is the port number of the ingress port.\",\"format\":\"int32\",\"type\":\"integer\"},\"protocol\":{\"default\":\"\",\"description\":\"protocol is the protocol of the ingress port. The supported values are: \\\"TCP\\\", \\\"UDP\\\", \\\"SCTP\\\"\",\"type\":\"string\"}},\"required\":[\"port\",\"protocol\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressRule\":{\"description\":\"IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue.\",\"properties\":{\"host\":{\"description\":\"host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \\\"host\\\" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to\\n the IP in the Spec of the parent Ingress.\\n2. The `:` delimiter is not respected because ports are not allowed.\\n\\t Currently the port of an Ingress is implicitly :80 for http and\\n\\t :443 for https.\\nBoth these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue.\\n\\nhost can be \\\"precise\\\" which is a domain name without the terminating dot of a network host (e.g. \\\"foo.bar.com\\\") or \\\"wildcard\\\", which is a domain name prefixed with a single wildcard label (e.g. \\\"*.foo.com\\\"). The wildcard character '*' must appear by itself as the first DNS label and matches only a single label. You cannot have a wildcard label by itself (e.g. Host == \\\"*\\\"). Requests will be matched against the Host field in the following way: 1. If host is precise, the request matches this rule if the http host header is equal to Host. 2. If host is a wildcard, then the request matches this rule if the http host header is to equal to the suffix (removing the first label) of the wildcard rule.\",\"type\":\"string\"},\"http\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressServiceBackend\":{\"description\":\"IngressServiceBackend references a Kubernetes Service as a Backend.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"name is the referenced service. The service must exist in the same namespace as the Ingress object.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressSpec\":{\"description\":\"IngressSpec describes the Ingress the user wishes to exist.\",\"properties\":{\"defaultBackend\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressBackend\"},\"ingressClassName\":{\"description\":\"ingressClassName is the name of an IngressClass cluster resource. Ingress controller implementations use this field to know whether they should be serving this Ingress resource, by a transitive connection (controller -> IngressClass -> Ingress resource). Although the `kubernetes.io/ingress.class` annotation (simple constant name) was never formally defined, it was widely supported by Ingress controllers to create a direct binding between Ingress controller and Ingress resources. Newly created Ingress resources should prefer using the field. However, even though the annotation is officially deprecated, for backwards compatibility reasons, ingress controllers should still honor that annotation if present.\",\"type\":\"string\"},\"rules\":{\"description\":\"rules is a list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"tls\":{\"description\":\"tls represents the TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressTLS\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressStatus\":{\"description\":\"IngressStatus describe the current state of the Ingress.\",\"properties\":{\"loadBalancer\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.IngressTLS\":{\"description\":\"IngressTLS describes the transport layer security associated with an ingress.\",\"properties\":{\"hosts\":{\"description\":\"hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"secretName\":{\"description\":\"secretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \\\"Host\\\" header field used by an IngressRule, the SNI host is used for termination and value of the \\\"Host\\\" header is used for routing.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.NetworkPolicy\":{\"description\":\"NetworkPolicy describes what network traffic is allowed for a set of Pods\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.NetworkPolicyEgressRule\":{\"description\":\"NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8\",\"properties\":{\"ports\":{\"description\":\"ports is a list of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"to\":{\"description\":\"to is a list of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.NetworkPolicyIngressRule\":{\"description\":\"NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from.\",\"properties\":{\"from\":{\"description\":\"from is a list of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ports\":{\"description\":\"ports is a list of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.NetworkPolicyList\":{\"description\":\"NetworkPolicyList is a list of NetworkPolicy objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of schema objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicyList\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.NetworkPolicyPeer\":{\"description\":\"NetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed\",\"properties\":{\"ipBlock\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPBlock\"},\"namespaceSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"podSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.NetworkPolicyPort\":{\"description\":\"NetworkPolicyPort describes a port to allow traffic on\",\"properties\":{\"endPort\":{\"description\":\"endPort indicates that the range of ports from port to endPort if set, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port.\",\"format\":\"int32\",\"type\":\"integer\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"protocol\":{\"description\":\"protocol represents the protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.networking.v1.NetworkPolicySpec\":{\"description\":\"NetworkPolicySpec provides the specification of a NetworkPolicy\",\"properties\":{\"egress\":{\"description\":\"egress is a list of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ingress\":{\"description\":\"ingress is a list of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default)\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"podSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"policyTypes\":{\"description\":\"policyTypes is a list of rule types that the NetworkPolicy relates to. Valid options are [\\\"Ingress\\\"], [\\\"Egress\\\"], or [\\\"Ingress\\\", \\\"Egress\\\"]. If this field is not specified, it will default based on the existence of ingress or egress rules; policies that contain an egress section are assumed to affect egress, and all policies (whether or not they contain an ingress section) are assumed to affect ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \\\"Egress\\\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \\\"Egress\\\" (since such a policy would not include an egress section and would otherwise default to just [ \\\"Ingress\\\" ]). This field is beta-level in 1.8\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.ParentReference\":{\"description\":\"ParentReference describes a reference to a parent object.\",\"properties\":{\"group\":{\"description\":\"Group is the group of the object being referenced.\",\"type\":\"string\"},\"name\":{\"description\":\"Name is the name of the object being referenced.\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace is the namespace of the object being referenced.\",\"type\":\"string\"},\"resource\":{\"description\":\"Resource is the resource of the object being referenced.\",\"type\":\"string\"}},\"required\":[\"resource\",\"name\"],\"type\":\"object\"},\"io.k8s.api.networking.v1.ServiceBackendPort\":{\"description\":\"ServiceBackendPort is the service port being referenced.\",\"properties\":{\"name\":{\"description\":\"name is the name of the port on the Service. This is a mutually exclusive setting with \\\"Number\\\".\",\"type\":\"string\"},\"number\":{\"description\":\"number is the numerical port number (e.g. 80) on the Service. This is a mutually exclusive setting with \\\"Name\\\".\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.networking.v1.ServiceCIDR\":{\"description\":\"ServiceCIDR defines a range of IP addresses using CIDR format (e.g. 192.168.0.0/24 or 2001:db2::/64). This range is used to allocate ClusterIPs to Service objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.ServiceCIDRList\":{\"description\":\"ServiceCIDRList contains a list of ServiceCIDR objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of ServiceCIDRs.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDRList\",\"version\":\"v1\"}]},\"io.k8s.api.networking.v1.ServiceCIDRSpec\":{\"description\":\"ServiceCIDRSpec define the CIDRs the user wants to use for allocating ClusterIPs for Services.\",\"properties\":{\"cidrs\":{\"description\":\"CIDRs defines the IP blocks in CIDR notation (e.g. \\\"192.168.0.0/24\\\" or \\\"2001:db8::/64\\\") from which to assign service cluster IPs. Max of two CIDRs is allowed, one of each IP family. This field is immutable.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.networking.v1.ServiceCIDRStatus\":{\"description\":\"ServiceCIDRStatus describes the current state of the ServiceCIDR.\",\"properties\":{\"conditions\":{\"description\":\"conditions holds an array of metav1.Condition that describe the state of the ServiceCIDR. Current service state\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.Condition\":{\"description\":\"Condition contains details for one aspect of the current state of this API Resource.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"default\":\"\",\"description\":\"message is a human readable message indicating details about the transition. This may be an empty string.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.\",\"format\":\"int64\",\"type\":\"integer\"},\"reason\":{\"default\":\"\",\"description\":\"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type of condition in CamelCase or in foo.example.com/CamelCase.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\",\"lastTransitionTime\",\"reason\",\"message\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.util.intstr.IntOrString\":{\"description\":\"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.\",\"format\":\"int-or-string\",\"oneOf\":[{\"type\":\"integer\"},{\"type\":\"string\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/networking.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getNetworkingV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"]}},\"/apis/networking.k8s.io/v1/ingressclasses\":{\"delete\":{\"description\":\"delete collection of IngressClass\",\"operationId\":\"deleteNetworkingV1CollectionIngressClass\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind IngressClass\",\"operationId\":\"listNetworkingV1IngressClass\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClassList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an IngressClass\",\"operationId\":\"createNetworkingV1IngressClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/ingressclasses/{name}\":{\"delete\":{\"description\":\"delete an IngressClass\",\"operationId\":\"deleteNetworkingV1IngressClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified IngressClass\",\"operationId\":\"readNetworkingV1IngressClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the IngressClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified IngressClass\",\"operationId\":\"patchNetworkingV1IngressClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified IngressClass\",\"operationId\":\"replaceNetworkingV1IngressClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/ingresses\":{\"get\":{\"description\":\"list or watch objects of kind Ingress\",\"operationId\":\"listNetworkingV1IngressForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/ipaddresses\":{\"delete\":{\"description\":\"delete collection of IPAddress\",\"operationId\":\"deleteNetworkingV1CollectionIPAddress\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind IPAddress\",\"operationId\":\"listNetworkingV1IPAddress\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddressList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an IPAddress\",\"operationId\":\"createNetworkingV1IPAddress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/ipaddresses/{name}\":{\"delete\":{\"description\":\"delete an IPAddress\",\"operationId\":\"deleteNetworkingV1IPAddress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified IPAddress\",\"operationId\":\"readNetworkingV1IPAddress\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the IPAddress\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified IPAddress\",\"operationId\":\"patchNetworkingV1IPAddress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified IPAddress\",\"operationId\":\"replaceNetworkingV1IPAddress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IPAddress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses\":{\"delete\":{\"description\":\"delete collection of Ingress\",\"operationId\":\"deleteNetworkingV1CollectionNamespacedIngress\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Ingress\",\"operationId\":\"listNetworkingV1NamespacedIngress\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.IngressList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an Ingress\",\"operationId\":\"createNetworkingV1NamespacedIngress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}\":{\"delete\":{\"description\":\"delete an Ingress\",\"operationId\":\"deleteNetworkingV1NamespacedIngress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Ingress\",\"operationId\":\"readNetworkingV1NamespacedIngress\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Ingress\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Ingress\",\"operationId\":\"patchNetworkingV1NamespacedIngress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Ingress\",\"operationId\":\"replaceNetworkingV1NamespacedIngress\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status\":{\"get\":{\"description\":\"read status of the specified Ingress\",\"operationId\":\"readNetworkingV1NamespacedIngressStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Ingress\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Ingress\",\"operationId\":\"patchNetworkingV1NamespacedIngressStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Ingress\",\"operationId\":\"replaceNetworkingV1NamespacedIngressStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.Ingress\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies\":{\"delete\":{\"description\":\"delete collection of NetworkPolicy\",\"operationId\":\"deleteNetworkingV1CollectionNamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind NetworkPolicy\",\"operationId\":\"listNetworkingV1NamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a NetworkPolicy\",\"operationId\":\"createNetworkingV1NamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}\":{\"delete\":{\"description\":\"delete a NetworkPolicy\",\"operationId\":\"deleteNetworkingV1NamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified NetworkPolicy\",\"operationId\":\"readNetworkingV1NamespacedNetworkPolicy\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the NetworkPolicy\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified NetworkPolicy\",\"operationId\":\"patchNetworkingV1NamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified NetworkPolicy\",\"operationId\":\"replaceNetworkingV1NamespacedNetworkPolicy\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicy\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/networkpolicies\":{\"get\":{\"description\":\"list or watch objects of kind NetworkPolicy\",\"operationId\":\"listNetworkingV1NetworkPolicyForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/servicecidrs\":{\"delete\":{\"description\":\"delete collection of ServiceCIDR\",\"operationId\":\"deleteNetworkingV1CollectionServiceCIDR\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ServiceCIDR\",\"operationId\":\"listNetworkingV1ServiceCIDR\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ServiceCIDR\",\"operationId\":\"createNetworkingV1ServiceCIDR\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/servicecidrs/{name}\":{\"delete\":{\"description\":\"delete a ServiceCIDR\",\"operationId\":\"deleteNetworkingV1ServiceCIDR\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ServiceCIDR\",\"operationId\":\"readNetworkingV1ServiceCIDR\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ServiceCIDR\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ServiceCIDR\",\"operationId\":\"patchNetworkingV1ServiceCIDR\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ServiceCIDR\",\"operationId\":\"replaceNetworkingV1ServiceCIDR\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/servicecidrs/{name}/status\":{\"get\":{\"description\":\"read status of the specified ServiceCIDR\",\"operationId\":\"readNetworkingV1ServiceCIDRStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ServiceCIDR\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified ServiceCIDR\",\"operationId\":\"patchNetworkingV1ServiceCIDRStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified ServiceCIDR\",\"operationId\":\"replaceNetworkingV1ServiceCIDRStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.api.networking.v1.ServiceCIDR\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}}},\"/apis/networking.k8s.io/v1/watch/ingressclasses\":{\"get\":{\"description\":\"watch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1IngressClassList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/ingressclasses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNetworkingV1IngressClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IngressClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the IngressClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/ingresses\":{\"get\":{\"description\":\"watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1IngressListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/ipaddresses\":{\"get\":{\"description\":\"watch individual changes to a list of IPAddress. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1IPAddressList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/ipaddresses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind IPAddress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNetworkingV1IPAddress\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"IPAddress\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the IPAddress\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses\":{\"get\":{\"description\":\"watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1NamespacedIngressList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNetworkingV1NamespacedIngress\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"Ingress\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Ingress\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies\":{\"get\":{\"description\":\"watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1NamespacedNetworkPolicyList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNetworkingV1NamespacedNetworkPolicy\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the NetworkPolicy\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/networkpolicies\":{\"get\":{\"description\":\"watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1NetworkPolicyListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"NetworkPolicy\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/servicecidrs\":{\"get\":{\"description\":\"watch individual changes to a list of ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNetworkingV1ServiceCIDRList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/networking.k8s.io/v1/watch/servicecidrs/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNetworkingV1ServiceCIDR\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-7c11a0514645f836457f.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"networking_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"networking.k8s.io\",\"kind\":\"ServiceCIDR\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ServiceCIDR\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPBlock", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.Ingress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressBackend", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClass", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressPortStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressTLS", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ParentReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDR", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiCoreV1TypedLocalObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, value) = _decode(IoK8sApiCoreV1TypedLocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedLocalObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedLocalObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ServiceBackendPort + name::Union{Absent,Nothing,String} = ABSENT + number::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ServiceBackendPort}, value) = _decode(IoK8sApiNetworkingV1ServiceBackendPort, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ServiceBackendPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort"), _openapi_raw, "decoding IoK8sApiNetworkingV1ServiceBackendPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ServiceBackendPort") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_number = haskey(_openapi_object, "number") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["number"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","number") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ServiceBackendPort(; name = _openapi_field_name, number = _openapi_field_number, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ServiceBackendPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.number isa Absent || (_openapi_output["number"] = _encode(_openapi_value.number)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceBackendPort"), _openapi_output, "encoding IoK8sApiNetworkingV1ServiceBackendPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ServiceBackendPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.number isa Absent || push!(_openapi_output, "number" => _openapi_value.number) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressServiceBackend + name::String + port::Union{Absent,IoK8sApiNetworkingV1ServiceBackendPort,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressServiceBackend}, value) = _decode(IoK8sApiNetworkingV1IngressServiceBackend, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressServiceBackend}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressServiceBackend"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressServiceBackend") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiNetworkingV1IngressServiceBackend"), _openapi_validate) + _openapi_field_port = haskey(_openapi_object, "port") ? _decode(Union{Absent,IoK8sApiNetworkingV1ServiceBackendPort,Nothing}, _openapi_object["port"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressServiceBackend(; name = _openapi_field_name, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressServiceBackend) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressServiceBackend"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressServiceBackend"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressServiceBackend) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressBackend + resource::Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing} = ABSENT + service::Union{Absent,IoK8sApiNetworkingV1IngressServiceBackend,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressBackend}, value) = _decode(IoK8sApiNetworkingV1IngressBackend, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressBackend}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressBackend"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressBackend"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressBackend") + _openapi_field_resource = haskey(_openapi_object, "resource") ? _decode(Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing}, _openapi_object["resource"], _openapi_validate) : ABSENT + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressServiceBackend,Nothing}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resource","service") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressBackend(; resource = _openapi_field_resource, service = _openapi_field_service, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressBackend) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressBackend"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressBackend"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressBackend) + _openapi_output = Pair{String,Any}[] + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1HTTPIngressPath + backend::IoK8sApiNetworkingV1IngressBackend + path::Union{Absent,Nothing,String} = ABSENT + pathtype::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1HTTPIngressPath}, value) = _decode(IoK8sApiNetworkingV1HTTPIngressPath, value, true) +function _decode(::Type{IoK8sApiNetworkingV1HTTPIngressPath}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath"), _openapi_raw, "decoding IoK8sApiNetworkingV1HTTPIngressPath"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1HTTPIngressPath") + _openapi_field_backend = _decode(IoK8sApiNetworkingV1IngressBackend, _required(_openapi_object, "backend", "IoK8sApiNetworkingV1HTTPIngressPath"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_pathtype = _decode(String, _required(_openapi_object, "pathType", "IoK8sApiNetworkingV1HTTPIngressPath"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("backend","path","pathType") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1HTTPIngressPath(; backend = _openapi_field_backend, path = _openapi_field_path, pathtype = _openapi_field_pathtype, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1HTTPIngressPath) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.backend isa Absent || (_openapi_output["backend"] = _encode(_openapi_value.backend)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.pathtype isa Absent || (_openapi_output["pathType"] = _encode(_openapi_value.pathtype)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressPath"), _openapi_output, "encoding IoK8sApiNetworkingV1HTTPIngressPath"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1HTTPIngressPath) + _openapi_output = Pair{String,Any}[] + _openapi_value.backend isa Absent || push!(_openapi_output, "backend" => _openapi_value.backend) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.pathtype isa Absent || push!(_openapi_output, "pathType" => _openapi_value.pathtype) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1HTTPIngressRuleValue + paths::Union{Nothing,Vector{IoK8sApiNetworkingV1HTTPIngressPath}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1HTTPIngressRuleValue}, value) = _decode(IoK8sApiNetworkingV1HTTPIngressRuleValue, value, true) +function _decode(::Type{IoK8sApiNetworkingV1HTTPIngressRuleValue}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue"), _openapi_raw, "decoding IoK8sApiNetworkingV1HTTPIngressRuleValue"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1HTTPIngressRuleValue") + _openapi_field_paths = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1HTTPIngressPath}}, _required(_openapi_object, "paths", "IoK8sApiNetworkingV1HTTPIngressRuleValue"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("paths",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1HTTPIngressRuleValue(; paths = _openapi_field_paths, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1HTTPIngressRuleValue) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.paths isa Absent || (_openapi_output["paths"] = _encode(_openapi_value.paths)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.HTTPIngressRuleValue"), _openapi_output, "encoding IoK8sApiNetworkingV1HTTPIngressRuleValue"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1HTTPIngressRuleValue) + _openapi_output = Pair{String,Any}[] + _openapi_value.paths isa Absent || push!(_openapi_output, "paths" => _openapi_value.paths) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ParentReference + group::Union{Absent,Nothing,String} = ABSENT + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + resource::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ParentReference}, value) = _decode(IoK8sApiNetworkingV1ParentReference, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ParentReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ParentReference"), _openapi_raw, "decoding IoK8sApiNetworkingV1ParentReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ParentReference") + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiNetworkingV1ParentReference"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resource = _decode(String, _required(_openapi_object, "resource", "IoK8sApiNetworkingV1ParentReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("group","name","namespace","resource") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ParentReference(; group = _openapi_field_group, name = _openapi_field_name, namespace = _openapi_field_namespace, resource = _openapi_field_resource, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ParentReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ParentReference"), _openapi_output, "encoding IoK8sApiNetworkingV1ParentReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ParentReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IPAddressSpec + parentref::IoK8sApiNetworkingV1ParentReference + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IPAddressSpec}, value) = _decode(IoK8sApiNetworkingV1IPAddressSpec, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IPAddressSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressSpec"), _openapi_raw, "decoding IoK8sApiNetworkingV1IPAddressSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IPAddressSpec") + _openapi_field_parentref = _decode(IoK8sApiNetworkingV1ParentReference, _required(_openapi_object, "parentRef", "IoK8sApiNetworkingV1IPAddressSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("parentRef",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IPAddressSpec(; parentref = _openapi_field_parentref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IPAddressSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.parentref isa Absent || (_openapi_output["parentRef"] = _encode(_openapi_value.parentref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressSpec"), _openapi_output, "encoding IoK8sApiNetworkingV1IPAddressSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IPAddressSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.parentref isa Absent || push!(_openapi_output, "parentRef" => _openapi_value.parentref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IPAddress + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiNetworkingV1IPAddressSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IPAddress}, value) = _decode(IoK8sApiNetworkingV1IPAddress, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IPAddress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddress"), _openapi_raw, "decoding IoK8sApiNetworkingV1IPAddress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IPAddress") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiNetworkingV1IPAddressSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IPAddress(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IPAddress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddress"), _openapi_output, "encoding IoK8sApiNetworkingV1IPAddress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IPAddress) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IPAddressList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNetworkingV1IPAddress}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IPAddressList}, value) = _decode(IoK8sApiNetworkingV1IPAddressList, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IPAddressList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressList"), _openapi_raw, "decoding IoK8sApiNetworkingV1IPAddressList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IPAddressList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1IPAddress}}, _required(_openapi_object, "items", "IoK8sApiNetworkingV1IPAddressList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IPAddressList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IPAddressList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPAddressList"), _openapi_output, "encoding IoK8sApiNetworkingV1IPAddressList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IPAddressList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IPBlock + cidr::String + except::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IPBlock}, value) = _decode(IoK8sApiNetworkingV1IPBlock, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IPBlock}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPBlock"), _openapi_raw, "decoding IoK8sApiNetworkingV1IPBlock"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IPBlock") + _openapi_field_cidr = _decode(String, _required(_openapi_object, "cidr", "IoK8sApiNetworkingV1IPBlock"), _openapi_validate) + _openapi_field_except = haskey(_openapi_object, "except") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["except"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cidr","except") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IPBlock(; cidr = _openapi_field_cidr, except = _openapi_field_except, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IPBlock) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cidr isa Absent || (_openapi_output["cidr"] = _encode(_openapi_value.cidr)) + _openapi_value.except isa Absent || (_openapi_output["except"] = _encode(_openapi_value.except)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IPBlock"), _openapi_output, "encoding IoK8sApiNetworkingV1IPBlock"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IPBlock) + _openapi_output = Pair{String,Any}[] + _openapi_value.cidr isa Absent || push!(_openapi_output, "cidr" => _openapi_value.cidr) + _openapi_value.except isa Absent || push!(_openapi_output, "except" => _openapi_value.except) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressRule + host::Union{Absent,Nothing,String} = ABSENT + http::Union{Absent,IoK8sApiNetworkingV1HTTPIngressRuleValue,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressRule}, value) = _decode(IoK8sApiNetworkingV1IngressRule, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressRule"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressRule") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_http = haskey(_openapi_object, "http") ? _decode(Union{Absent,IoK8sApiNetworkingV1HTTPIngressRuleValue,Nothing}, _openapi_object["http"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","http") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressRule(; host = _openapi_field_host, http = _openapi_field_http, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.http isa Absent || (_openapi_output["http"] = _encode(_openapi_value.http)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressRule"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.http isa Absent || push!(_openapi_output, "http" => _openapi_value.http) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressTLS + hosts::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + secretname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressTLS}, value) = _decode(IoK8sApiNetworkingV1IngressTLS, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressTLS}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressTLS"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressTLS"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressTLS") + _openapi_field_hosts = haskey(_openapi_object, "hosts") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["hosts"], _openapi_validate) : ABSENT + _openapi_field_secretname = haskey(_openapi_object, "secretName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hosts","secretName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressTLS(; hosts = _openapi_field_hosts, secretname = _openapi_field_secretname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressTLS) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hosts isa Absent || (_openapi_output["hosts"] = _encode(_openapi_value.hosts)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressTLS"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressTLS"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressTLS) + _openapi_output = Pair{String,Any}[] + _openapi_value.hosts isa Absent || push!(_openapi_output, "hosts" => _openapi_value.hosts) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressSpec + defaultbackend::Union{Absent,IoK8sApiNetworkingV1IngressBackend,Nothing} = ABSENT + ingressclassname::Union{Absent,Nothing,String} = ABSENT + rules::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressRule}}} = ABSENT + tls::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressTLS}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressSpec}, value) = _decode(IoK8sApiNetworkingV1IngressSpec, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressSpec"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressSpec") + _openapi_field_defaultbackend = haskey(_openapi_object, "defaultBackend") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressBackend,Nothing}, _openapi_object["defaultBackend"], _openapi_validate) : ABSENT + _openapi_field_ingressclassname = haskey(_openapi_object, "ingressClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["ingressClassName"], _openapi_validate) : ABSENT + _openapi_field_rules = haskey(_openapi_object, "rules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressRule}}}, _openapi_object["rules"], _openapi_validate) : ABSENT + _openapi_field_tls = haskey(_openapi_object, "tls") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressTLS}}}, _openapi_object["tls"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultBackend","ingressClassName","rules","tls") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressSpec(; defaultbackend = _openapi_field_defaultbackend, ingressclassname = _openapi_field_ingressclassname, rules = _openapi_field_rules, tls = _openapi_field_tls, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultbackend isa Absent || (_openapi_output["defaultBackend"] = _encode(_openapi_value.defaultbackend)) + _openapi_value.ingressclassname isa Absent || (_openapi_output["ingressClassName"] = _encode(_openapi_value.ingressclassname)) + _openapi_value.rules isa Absent || (_openapi_output["rules"] = _encode(_openapi_value.rules)) + _openapi_value.tls isa Absent || (_openapi_output["tls"] = _encode(_openapi_value.tls)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressSpec"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultbackend isa Absent || push!(_openapi_output, "defaultBackend" => _openapi_value.defaultbackend) + _openapi_value.ingressclassname isa Absent || push!(_openapi_output, "ingressClassName" => _openapi_value.ingressclassname) + _openapi_value.rules isa Absent || push!(_openapi_output, "rules" => _openapi_value.rules) + _openapi_value.tls isa Absent || push!(_openapi_output, "tls" => _openapi_value.tls) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressPortStatus + error::Union{Absent,Nothing,String} = ABSENT + port::Int32 + protocol::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressPortStatus}, value) = _decode(IoK8sApiNetworkingV1IngressPortStatus, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressPortStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressPortStatus"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressPortStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressPortStatus") + _openapi_field_error = haskey(_openapi_object, "error") ? _decode(Union{Absent,Nothing,String}, _openapi_object["error"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiNetworkingV1IngressPortStatus"), _openapi_validate) + _openapi_field_protocol = _decode(String, _required(_openapi_object, "protocol", "IoK8sApiNetworkingV1IngressPortStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("error","port","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressPortStatus(; error = _openapi_field_error, port = _openapi_field_port, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressPortStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.error isa Absent || (_openapi_output["error"] = _encode(_openapi_value.error)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressPortStatus"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressPortStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressPortStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.error isa Absent || push!(_openapi_output, "error" => _openapi_value.error) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressLoadBalancerIngress + hostname::Union{Absent,Nothing,String} = ABSENT + ip::Union{Absent,Nothing,String} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressPortStatus}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressLoadBalancerIngress}, value) = _decode(IoK8sApiNetworkingV1IngressLoadBalancerIngress, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressLoadBalancerIngress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressLoadBalancerIngress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressLoadBalancerIngress") + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_ip = haskey(_openapi_object, "ip") ? _decode(Union{Absent,Nothing,String}, _openapi_object["ip"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressPortStatus}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostname","ip","ports") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressLoadBalancerIngress(; hostname = _openapi_field_hostname, ip = _openapi_field_ip, ports = _openapi_field_ports, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressLoadBalancerIngress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerIngress"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressLoadBalancerIngress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressLoadBalancerIngress) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressLoadBalancerStatus + ingress::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressLoadBalancerIngress}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressLoadBalancerStatus}, value) = _decode(IoK8sApiNetworkingV1IngressLoadBalancerStatus, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressLoadBalancerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressLoadBalancerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressLoadBalancerStatus") + _openapi_field_ingress = haskey(_openapi_object, "ingress") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1IngressLoadBalancerIngress}}}, _openapi_object["ingress"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ingress",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressLoadBalancerStatus(; ingress = _openapi_field_ingress, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressLoadBalancerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ingress isa Absent || (_openapi_output["ingress"] = _encode(_openapi_value.ingress)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressLoadBalancerStatus"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressLoadBalancerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressLoadBalancerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.ingress isa Absent || push!(_openapi_output, "ingress" => _openapi_value.ingress) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressStatus + loadbalancer::Union{Absent,IoK8sApiNetworkingV1IngressLoadBalancerStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressStatus}, value) = _decode(IoK8sApiNetworkingV1IngressStatus, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressStatus"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressStatus") + _openapi_field_loadbalancer = haskey(_openapi_object, "loadBalancer") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressLoadBalancerStatus,Nothing}, _openapi_object["loadBalancer"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("loadBalancer",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressStatus(; loadbalancer = _openapi_field_loadbalancer, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.loadbalancer isa Absent || (_openapi_output["loadBalancer"] = _encode(_openapi_value.loadbalancer)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressStatus"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.loadbalancer isa Absent || push!(_openapi_output, "loadBalancer" => _openapi_value.loadbalancer) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1Ingress + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiNetworkingV1IngressSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiNetworkingV1IngressStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1Ingress}, value) = _decode(IoK8sApiNetworkingV1Ingress, value, true) +function _decode(::Type{IoK8sApiNetworkingV1Ingress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.Ingress"), _openapi_raw, "decoding IoK8sApiNetworkingV1Ingress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1Ingress") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1Ingress(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1Ingress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.Ingress"), _openapi_output, "encoding IoK8sApiNetworkingV1Ingress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1Ingress) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressClassParametersReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + scope::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressClassParametersReference}, value) = _decode(IoK8sApiNetworkingV1IngressClassParametersReference, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressClassParametersReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressClassParametersReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressClassParametersReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiNetworkingV1IngressClassParametersReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiNetworkingV1IngressClassParametersReference"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_scope = haskey(_openapi_object, "scope") ? _decode(Union{Absent,Nothing,String}, _openapi_object["scope"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name","namespace","scope") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressClassParametersReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, scope = _openapi_field_scope, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressClassParametersReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.scope isa Absent || (_openapi_output["scope"] = _encode(_openapi_value.scope)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassParametersReference"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressClassParametersReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressClassParametersReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.scope isa Absent || push!(_openapi_output, "scope" => _openapi_value.scope) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressClassSpec + controller::Union{Absent,Nothing,String} = ABSENT + parameters::Union{Absent,IoK8sApiNetworkingV1IngressClassParametersReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressClassSpec}, value) = _decode(IoK8sApiNetworkingV1IngressClassSpec, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressClassSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassSpec"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressClassSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressClassSpec") + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Nothing,String}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_parameters = haskey(_openapi_object, "parameters") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressClassParametersReference,Nothing}, _openapi_object["parameters"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("controller","parameters") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressClassSpec(; controller = _openapi_field_controller, parameters = _openapi_field_parameters, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressClassSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.parameters isa Absent || (_openapi_output["parameters"] = _encode(_openapi_value.parameters)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassSpec"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressClassSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressClassSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.parameters isa Absent || push!(_openapi_output, "parameters" => _openapi_value.parameters) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressClass + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiNetworkingV1IngressClassSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressClass}, value) = _decode(IoK8sApiNetworkingV1IngressClass, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressClass}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClass"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressClass"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressClass") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiNetworkingV1IngressClassSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressClass(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressClass) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClass"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressClass"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressClass) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressClassList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNetworkingV1IngressClass}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressClassList}, value) = _decode(IoK8sApiNetworkingV1IngressClassList, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressClassList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassList"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressClassList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressClassList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1IngressClass}}, _required(_openapi_object, "items", "IoK8sApiNetworkingV1IngressClassList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressClassList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressClassList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressClassList"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressClassList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressClassList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1IngressList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNetworkingV1Ingress}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1IngressList}, value) = _decode(IoK8sApiNetworkingV1IngressList, value, true) +function _decode(::Type{IoK8sApiNetworkingV1IngressList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressList"), _openapi_raw, "decoding IoK8sApiNetworkingV1IngressList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1IngressList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1Ingress}}, _required(_openapi_object, "items", "IoK8sApiNetworkingV1IngressList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1IngressList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1IngressList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.IngressList"), _openapi_output, "encoding IoK8sApiNetworkingV1IngressList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1IngressList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgUtilIntstrIntOrString + value::Union{Int64,String} +end +_decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value) = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, value, true) +function _decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), value, "decoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(Int64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgUtilIntstrIntOrString")) + return IoK8sApimachineryPkgUtilIntstrIntOrString(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgUtilIntstrIntOrString) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), output, "encoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicyPort + endport::Union{Absent,Int32,Nothing} = ABSENT + port::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicyPort}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicyPort, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicyPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicyPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicyPort") + _openapi_field_endport = haskey(_openapi_object, "endPort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["endPort"], _openapi_validate) : ABSENT + _openapi_field_port = haskey(_openapi_object, "port") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["port"], _openapi_validate) : ABSENT + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endPort","port","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicyPort(; endport = _openapi_field_endport, port = _openapi_field_port, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endport isa Absent || (_openapi_output["endPort"] = _encode(_openapi_value.endport)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPort"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicyPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.endport isa Absent || push!(_openapi_output, "endPort" => _openapi_value.endport) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicyPeer + ipblock::Union{Absent,IoK8sApiNetworkingV1IPBlock,Nothing} = ABSENT + namespaceselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + podselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicyPeer}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicyPeer, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicyPeer}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicyPeer"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicyPeer") + _openapi_field_ipblock = haskey(_openapi_object, "ipBlock") ? _decode(Union{Absent,IoK8sApiNetworkingV1IPBlock,Nothing}, _openapi_object["ipBlock"], _openapi_validate) : ABSENT + _openapi_field_namespaceselector = haskey(_openapi_object, "namespaceSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["namespaceSelector"], _openapi_validate) : ABSENT + _openapi_field_podselector = haskey(_openapi_object, "podSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["podSelector"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ipBlock","namespaceSelector","podSelector") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicyPeer(; ipblock = _openapi_field_ipblock, namespaceselector = _openapi_field_namespaceselector, podselector = _openapi_field_podselector, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyPeer) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ipblock isa Absent || (_openapi_output["ipBlock"] = _encode(_openapi_value.ipblock)) + _openapi_value.namespaceselector isa Absent || (_openapi_output["namespaceSelector"] = _encode(_openapi_value.namespaceselector)) + _openapi_value.podselector isa Absent || (_openapi_output["podSelector"] = _encode(_openapi_value.podselector)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyPeer"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicyPeer"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyPeer) + _openapi_output = Pair{String,Any}[] + _openapi_value.ipblock isa Absent || push!(_openapi_output, "ipBlock" => _openapi_value.ipblock) + _openapi_value.namespaceselector isa Absent || push!(_openapi_output, "namespaceSelector" => _openapi_value.namespaceselector) + _openapi_value.podselector isa Absent || push!(_openapi_output, "podSelector" => _openapi_value.podselector) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicyEgressRule + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPort}}} = ABSENT + to::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicyEgressRule}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicyEgressRule, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicyEgressRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicyEgressRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicyEgressRule") + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_to = haskey(_openapi_object, "to") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}}}, _openapi_object["to"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ports","to") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicyEgressRule(; ports = _openapi_field_ports, to = _openapi_field_to, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyEgressRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.to isa Absent || (_openapi_output["to"] = _encode(_openapi_value.to)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyEgressRule"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicyEgressRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyEgressRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.to isa Absent || push!(_openapi_output, "to" => _openapi_value.to) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicyIngressRule + from::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}}} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPort}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicyIngressRule}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicyIngressRule, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicyIngressRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicyIngressRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicyIngressRule") + _openapi_field_from = haskey(_openapi_object, "from") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPeer}}}, _openapi_object["from"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("from","ports") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicyIngressRule(; from = _openapi_field_from, ports = _openapi_field_ports, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyIngressRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.from isa Absent || (_openapi_output["from"] = _encode(_openapi_value.from)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyIngressRule"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicyIngressRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyIngressRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.from isa Absent || push!(_openapi_output, "from" => _openapi_value.from) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicySpec + egress::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyEgressRule}}} = ABSENT + ingress::Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyIngressRule}}} = ABSENT + podselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + policytypes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicySpec}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicySpec, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicySpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicySpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicySpec") + _openapi_field_egress = haskey(_openapi_object, "egress") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyEgressRule}}}, _openapi_object["egress"], _openapi_validate) : ABSENT + _openapi_field_ingress = haskey(_openapi_object, "ingress") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicyIngressRule}}}, _openapi_object["ingress"], _openapi_validate) : ABSENT + _openapi_field_podselector = haskey(_openapi_object, "podSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["podSelector"], _openapi_validate) : ABSENT + _openapi_field_policytypes = haskey(_openapi_object, "policyTypes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["policyTypes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("egress","ingress","podSelector","policyTypes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicySpec(; egress = _openapi_field_egress, ingress = _openapi_field_ingress, podselector = _openapi_field_podselector, policytypes = _openapi_field_policytypes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicySpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.egress isa Absent || (_openapi_output["egress"] = _encode(_openapi_value.egress)) + _openapi_value.ingress isa Absent || (_openapi_output["ingress"] = _encode(_openapi_value.ingress)) + _openapi_value.podselector isa Absent || (_openapi_output["podSelector"] = _encode(_openapi_value.podselector)) + _openapi_value.policytypes isa Absent || (_openapi_output["policyTypes"] = _encode(_openapi_value.policytypes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicySpec"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicySpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicySpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.egress isa Absent || push!(_openapi_output, "egress" => _openapi_value.egress) + _openapi_value.ingress isa Absent || push!(_openapi_output, "ingress" => _openapi_value.ingress) + _openapi_value.podselector isa Absent || push!(_openapi_output, "podSelector" => _openapi_value.podselector) + _openapi_value.policytypes isa Absent || push!(_openapi_output, "policyTypes" => _openapi_value.policytypes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicy + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiNetworkingV1NetworkPolicySpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicy}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicy, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicy"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicy") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiNetworkingV1NetworkPolicySpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicy(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicy"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1NetworkPolicyList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicy}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1NetworkPolicyList}, value) = _decode(IoK8sApiNetworkingV1NetworkPolicyList, value, true) +function _decode(::Type{IoK8sApiNetworkingV1NetworkPolicyList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList"), _openapi_raw, "decoding IoK8sApiNetworkingV1NetworkPolicyList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1NetworkPolicyList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1NetworkPolicy}}, _required(_openapi_object, "items", "IoK8sApiNetworkingV1NetworkPolicyList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1NetworkPolicyList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.NetworkPolicyList"), _openapi_output, "encoding IoK8sApiNetworkingV1NetworkPolicyList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1NetworkPolicyList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ServiceCIDRSpec + cidrs::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ServiceCIDRSpec}, value) = _decode(IoK8sApiNetworkingV1ServiceCIDRSpec, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ServiceCIDRSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec"), _openapi_raw, "decoding IoK8sApiNetworkingV1ServiceCIDRSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ServiceCIDRSpec") + _openapi_field_cidrs = haskey(_openapi_object, "cidrs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["cidrs"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cidrs",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ServiceCIDRSpec(; cidrs = _openapi_field_cidrs, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cidrs isa Absent || (_openapi_output["cidrs"] = _encode(_openapi_value.cidrs)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRSpec"), _openapi_output, "encoding IoK8sApiNetworkingV1ServiceCIDRSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.cidrs isa Absent || push!(_openapi_output, "cidrs" => _openapi_value.cidrs) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Condition + lasttransitiontime::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + message::String + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + reason::String + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Condition, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Condition") + _openapi_field_lasttransitiontime = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "lastTransitionTime", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_message = _decode(String, _required(_openapi_object, "message", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_reason = _decode(String, _required(_openapi_object, "reason", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","observedGeneration","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Condition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, observedgeneration = _openapi_field_observedgeneration, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ServiceCIDRStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ServiceCIDRStatus}, value) = _decode(IoK8sApiNetworkingV1ServiceCIDRStatus, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ServiceCIDRStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus"), _openapi_raw, "decoding IoK8sApiNetworkingV1ServiceCIDRStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ServiceCIDRStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ServiceCIDRStatus(; conditions = _openapi_field_conditions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRStatus"), _openapi_output, "encoding IoK8sApiNetworkingV1ServiceCIDRStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ServiceCIDR + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiNetworkingV1ServiceCIDRSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiNetworkingV1ServiceCIDRStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ServiceCIDR}, value) = _decode(IoK8sApiNetworkingV1ServiceCIDR, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ServiceCIDR}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDR"), _openapi_raw, "decoding IoK8sApiNetworkingV1ServiceCIDR"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ServiceCIDR") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiNetworkingV1ServiceCIDRSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiNetworkingV1ServiceCIDRStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ServiceCIDR(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ServiceCIDR) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDR"), _openapi_output, "encoding IoK8sApiNetworkingV1ServiceCIDR"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ServiceCIDR) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNetworkingV1ServiceCIDRList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNetworkingV1ServiceCIDR}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNetworkingV1ServiceCIDRList}, value) = _decode(IoK8sApiNetworkingV1ServiceCIDRList, value, true) +function _decode(::Type{IoK8sApiNetworkingV1ServiceCIDRList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList"), _openapi_raw, "decoding IoK8sApiNetworkingV1ServiceCIDRList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNetworkingV1ServiceCIDRList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNetworkingV1ServiceCIDR}}, _required(_openapi_object, "items", "IoK8sApiNetworkingV1ServiceCIDRList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNetworkingV1ServiceCIDRList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.api.networking.v1.ServiceCIDRList"), _openapi_output, "encoding IoK8sApiNetworkingV1ServiceCIDRList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNetworkingV1ServiceCIDRList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getnetworkingv1apiresources = ( + id = "getNetworkingV1APIResources", + method = "GET", + path = "/apis/networking.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getnetworkingv1apiresources(...)\n\nget available resources\n\n`GET /apis/networking.k8s.io/v1/`" +function getnetworkingv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getnetworkingv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1collectioningressclass = ( + id = "deleteNetworkingV1CollectionIngressClass", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/ingressclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1collectioningressclass(...)\n\ndelete collection of IngressClass\n\n`DELETE /apis/networking.k8s.io/v1/ingressclasses`" +function deletenetworkingv1collectioningressclass(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenetworkingv1collectioningressclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1ingressclass = ( + id = "listNetworkingV1IngressClass", + method = "GET", + path = "/apis/networking.k8s.io/v1/ingressclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClassList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1ingressclass(...)\n\nlist or watch objects of kind IngressClass\n\n`GET /apis/networking.k8s.io/v1/ingressclasses`" +function listnetworkingv1ingressclass(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1ingressclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnetworkingv1ingressclass = ( + id = "createNetworkingV1IngressClass", + method = "POST", + path = "/apis/networking.k8s.io/v1/ingressclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnetworkingv1ingressclass(...)\n\ncreate an IngressClass\n\n`POST /apis/networking.k8s.io/v1/ingressclasses`" +function createnetworkingv1ingressclass(body::IoK8sApiNetworkingV1IngressClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnetworkingv1ingressclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1ingressclass = ( + id = "deleteNetworkingV1IngressClass", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/ingressclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1ingressclass(...)\n\ndelete an IngressClass\n\n`DELETE /apis/networking.k8s.io/v1/ingressclasses/{name}`" +function deletenetworkingv1ingressclass(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenetworkingv1ingressclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1ingressclass = ( + id = "readNetworkingV1IngressClass", + method = "GET", + path = "/apis/networking.k8s.io/v1/ingressclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1ingressclass(...)\n\nread the specified IngressClass\n\n`GET /apis/networking.k8s.io/v1/ingressclasses/{name}`" +function readnetworkingv1ingressclass(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnetworkingv1ingressclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1ingressclass = ( + id = "patchNetworkingV1IngressClass", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/ingressclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1ingressclass(...)\n\npartially update the specified IngressClass\n\n`PATCH /apis/networking.k8s.io/v1/ingressclasses/{name}`" +function patchnetworkingv1ingressclass(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1ingressclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1ingressclass = ( + id = "replaceNetworkingV1IngressClass", + method = "PUT", + path = "/apis/networking.k8s.io/v1/ingressclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressClass, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingressclasses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1ingressclass(...)\n\nreplace the specified IngressClass\n\n`PUT /apis/networking.k8s.io/v1/ingressclasses/{name}`" +function replacenetworkingv1ingressclass(name::String, body::IoK8sApiNetworkingV1IngressClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1ingressclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1ingressforallnamespaces = ( + id = "listNetworkingV1IngressForAllNamespaces", + method = "GET", + path = "/apis/networking.k8s.io/v1/ingresses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ingresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1ingressforallnamespaces(...)\n\nlist or watch objects of kind Ingress\n\n`GET /apis/networking.k8s.io/v1/ingresses`" +function listnetworkingv1ingressforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1ingressforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1collectionipaddress = ( + id = "deleteNetworkingV1CollectionIPAddress", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/ipaddresses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1collectionipaddress(...)\n\ndelete collection of IPAddress\n\n`DELETE /apis/networking.k8s.io/v1/ipaddresses`" +function deletenetworkingv1collectionipaddress(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenetworkingv1collectionipaddress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1ipaddress = ( + id = "listNetworkingV1IPAddress", + method = "GET", + path = "/apis/networking.k8s.io/v1/ipaddresses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1ipaddress(...)\n\nlist or watch objects of kind IPAddress\n\n`GET /apis/networking.k8s.io/v1/ipaddresses`" +function listnetworkingv1ipaddress(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1ipaddress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnetworkingv1ipaddress = ( + id = "createNetworkingV1IPAddress", + method = "POST", + path = "/apis/networking.k8s.io/v1/ipaddresses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnetworkingv1ipaddress(...)\n\ncreate an IPAddress\n\n`POST /apis/networking.k8s.io/v1/ipaddresses`" +function createnetworkingv1ipaddress(body::IoK8sApiNetworkingV1IPAddress; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnetworkingv1ipaddress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1ipaddress = ( + id = "deleteNetworkingV1IPAddress", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/ipaddresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1ipaddress(...)\n\ndelete an IPAddress\n\n`DELETE /apis/networking.k8s.io/v1/ipaddresses/{name}`" +function deletenetworkingv1ipaddress(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenetworkingv1ipaddress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1ipaddress = ( + id = "readNetworkingV1IPAddress", + method = "GET", + path = "/apis/networking.k8s.io/v1/ipaddresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1ipaddress(...)\n\nread the specified IPAddress\n\n`GET /apis/networking.k8s.io/v1/ipaddresses/{name}`" +function readnetworkingv1ipaddress(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnetworkingv1ipaddress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1ipaddress = ( + id = "patchNetworkingV1IPAddress", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/ipaddresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1ipaddress(...)\n\npartially update the specified IPAddress\n\n`PATCH /apis/networking.k8s.io/v1/ipaddresses/{name}`" +function patchnetworkingv1ipaddress(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1ipaddress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1ipaddress = ( + id = "replaceNetworkingV1IPAddress", + method = "PUT", + path = "/apis/networking.k8s.io/v1/ipaddresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IPAddress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1ipaddresses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1ipaddress(...)\n\nreplace the specified IPAddress\n\n`PUT /apis/networking.k8s.io/v1/ipaddresses/{name}`" +function replacenetworkingv1ipaddress(name::String, body::IoK8sApiNetworkingV1IPAddress; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1ipaddress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1collectionnamespacedingress = ( + id = "deleteNetworkingV1CollectionNamespacedIngress", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1collectionnamespacedingress(...)\n\ndelete collection of Ingress\n\n`DELETE /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses`" +function deletenetworkingv1collectionnamespacedingress(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenetworkingv1collectionnamespacedingress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1namespacedingress = ( + id = "listNetworkingV1NamespacedIngress", + method = "GET", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1IngressList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1namespacedingress(...)\n\nlist or watch objects of kind Ingress\n\n`GET /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses`" +function listnetworkingv1namespacedingress(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1namespacedingress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnetworkingv1namespacedingress = ( + id = "createNetworkingV1NamespacedIngress", + method = "POST", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnetworkingv1namespacedingress(...)\n\ncreate an Ingress\n\n`POST /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses`" +function createnetworkingv1namespacedingress(namespace::String, body::IoK8sApiNetworkingV1Ingress; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnetworkingv1namespacedingress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1namespacedingress = ( + id = "deleteNetworkingV1NamespacedIngress", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1namespacedingress(...)\n\ndelete an Ingress\n\n`DELETE /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}`" +function deletenetworkingv1namespacedingress(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenetworkingv1namespacedingress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1namespacedingress = ( + id = "readNetworkingV1NamespacedIngress", + method = "GET", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1namespacedingress(...)\n\nread the specified Ingress\n\n`GET /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}`" +function readnetworkingv1namespacedingress(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnetworkingv1namespacedingress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1namespacedingress = ( + id = "patchNetworkingV1NamespacedIngress", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1namespacedingress(...)\n\npartially update the specified Ingress\n\n`PATCH /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}`" +function patchnetworkingv1namespacedingress(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1namespacedingress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1namespacedingress = ( + id = "replaceNetworkingV1NamespacedIngress", + method = "PUT", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1namespacedingress(...)\n\nreplace the specified Ingress\n\n`PUT /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}`" +function replacenetworkingv1namespacedingress(namespace::String, name::String, body::IoK8sApiNetworkingV1Ingress; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1namespacedingress, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1namespacedingressstatus = ( + id = "readNetworkingV1NamespacedIngressStatus", + method = "GET", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1namespacedingressstatus(...)\n\nread status of the specified Ingress\n\n`GET /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status`" +function readnetworkingv1namespacedingressstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readnetworkingv1namespacedingressstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1namespacedingressstatus = ( + id = "patchNetworkingV1NamespacedIngressStatus", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1namespacedingressstatus(...)\n\npartially update status of the specified Ingress\n\n`PATCH /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status`" +function patchnetworkingv1namespacedingressstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1namespacedingressstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1namespacedingressstatus = ( + id = "replaceNetworkingV1NamespacedIngressStatus", + method = "PUT", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1Ingress, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1ingresses~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1namespacedingressstatus(...)\n\nreplace status of the specified Ingress\n\n`PUT /apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status`" +function replacenetworkingv1namespacedingressstatus(namespace::String, name::String, body::IoK8sApiNetworkingV1Ingress; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1namespacedingressstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1collectionnamespacednetworkpolicy = ( + id = "deleteNetworkingV1CollectionNamespacedNetworkPolicy", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1collectionnamespacednetworkpolicy(...)\n\ndelete collection of NetworkPolicy\n\n`DELETE /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies`" +function deletenetworkingv1collectionnamespacednetworkpolicy(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenetworkingv1collectionnamespacednetworkpolicy, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1namespacednetworkpolicy = ( + id = "listNetworkingV1NamespacedNetworkPolicy", + method = "GET", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1namespacednetworkpolicy(...)\n\nlist or watch objects of kind NetworkPolicy\n\n`GET /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies`" +function listnetworkingv1namespacednetworkpolicy(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1namespacednetworkpolicy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnetworkingv1namespacednetworkpolicy = ( + id = "createNetworkingV1NamespacedNetworkPolicy", + method = "POST", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnetworkingv1namespacednetworkpolicy(...)\n\ncreate a NetworkPolicy\n\n`POST /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies`" +function createnetworkingv1namespacednetworkpolicy(namespace::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnetworkingv1namespacednetworkpolicy, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1namespacednetworkpolicy = ( + id = "deleteNetworkingV1NamespacedNetworkPolicy", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1namespacednetworkpolicy(...)\n\ndelete a NetworkPolicy\n\n`DELETE /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}`" +function deletenetworkingv1namespacednetworkpolicy(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenetworkingv1namespacednetworkpolicy, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1namespacednetworkpolicy = ( + id = "readNetworkingV1NamespacedNetworkPolicy", + method = "GET", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1namespacednetworkpolicy(...)\n\nread the specified NetworkPolicy\n\n`GET /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}`" +function readnetworkingv1namespacednetworkpolicy(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnetworkingv1namespacednetworkpolicy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1namespacednetworkpolicy = ( + id = "patchNetworkingV1NamespacedNetworkPolicy", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1namespacednetworkpolicy(...)\n\npartially update the specified NetworkPolicy\n\n`PATCH /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}`" +function patchnetworkingv1namespacednetworkpolicy(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1namespacednetworkpolicy, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1namespacednetworkpolicy = ( + id = "replaceNetworkingV1NamespacedNetworkPolicy", + method = "PUT", + path = "/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicy, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1namespaces~1{namespace}~1networkpolicies~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1namespacednetworkpolicy(...)\n\nreplace the specified NetworkPolicy\n\n`PUT /apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}`" +function replacenetworkingv1namespacednetworkpolicy(namespace::String, name::String, body::IoK8sApiNetworkingV1NetworkPolicy; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1namespacednetworkpolicy, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1networkpolicyforallnamespaces = ( + id = "listNetworkingV1NetworkPolicyForAllNamespaces", + method = "GET", + path = "/apis/networking.k8s.io/v1/networkpolicies", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1NetworkPolicyList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1networkpolicies/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1networkpolicyforallnamespaces(...)\n\nlist or watch objects of kind NetworkPolicy\n\n`GET /apis/networking.k8s.io/v1/networkpolicies`" +function listnetworkingv1networkpolicyforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1networkpolicyforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1collectionservicecidr = ( + id = "deleteNetworkingV1CollectionServiceCIDR", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/servicecidrs", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1collectionservicecidr(...)\n\ndelete collection of ServiceCIDR\n\n`DELETE /apis/networking.k8s.io/v1/servicecidrs`" +function deletenetworkingv1collectionservicecidr(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenetworkingv1collectionservicecidr, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnetworkingv1servicecidr = ( + id = "listNetworkingV1ServiceCIDR", + method = "GET", + path = "/apis/networking.k8s.io/v1/servicecidrs", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDRList, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnetworkingv1servicecidr(...)\n\nlist or watch objects of kind ServiceCIDR\n\n`GET /apis/networking.k8s.io/v1/servicecidrs`" +function listnetworkingv1servicecidr(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnetworkingv1servicecidr, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnetworkingv1servicecidr = ( + id = "createNetworkingV1ServiceCIDR", + method = "POST", + path = "/apis/networking.k8s.io/v1/servicecidrs", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnetworkingv1servicecidr(...)\n\ncreate a ServiceCIDR\n\n`POST /apis/networking.k8s.io/v1/servicecidrs`" +function createnetworkingv1servicecidr(body::IoK8sApiNetworkingV1ServiceCIDR; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnetworkingv1servicecidr, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenetworkingv1servicecidr = ( + id = "deleteNetworkingV1ServiceCIDR", + method = "DELETE", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenetworkingv1servicecidr(...)\n\ndelete a ServiceCIDR\n\n`DELETE /apis/networking.k8s.io/v1/servicecidrs/{name}`" +function deletenetworkingv1servicecidr(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenetworkingv1servicecidr, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1servicecidr = ( + id = "readNetworkingV1ServiceCIDR", + method = "GET", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1servicecidr(...)\n\nread the specified ServiceCIDR\n\n`GET /apis/networking.k8s.io/v1/servicecidrs/{name}`" +function readnetworkingv1servicecidr(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnetworkingv1servicecidr, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1servicecidr = ( + id = "patchNetworkingV1ServiceCIDR", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1servicecidr(...)\n\npartially update the specified ServiceCIDR\n\n`PATCH /apis/networking.k8s.io/v1/servicecidrs/{name}`" +function patchnetworkingv1servicecidr(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1servicecidr, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1servicecidr = ( + id = "replaceNetworkingV1ServiceCIDR", + method = "PUT", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1servicecidr(...)\n\nreplace the specified ServiceCIDR\n\n`PUT /apis/networking.k8s.io/v1/servicecidrs/{name}`" +function replacenetworkingv1servicecidr(name::String, body::IoK8sApiNetworkingV1ServiceCIDR; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1servicecidr, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnetworkingv1servicecidrstatus = ( + id = "readNetworkingV1ServiceCIDRStatus", + method = "GET", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnetworkingv1servicecidrstatus(...)\n\nread status of the specified ServiceCIDR\n\n`GET /apis/networking.k8s.io/v1/servicecidrs/{name}/status`" +function readnetworkingv1servicecidrstatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readnetworkingv1servicecidrstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnetworkingv1servicecidrstatus = ( + id = "patchNetworkingV1ServiceCIDRStatus", + method = "PATCH", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnetworkingv1servicecidrstatus(...)\n\npartially update status of the specified ServiceCIDR\n\n`PATCH /apis/networking.k8s.io/v1/servicecidrs/{name}/status`" +function patchnetworkingv1servicecidrstatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnetworkingv1servicecidrstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenetworkingv1servicecidrstatus = ( + id = "replaceNetworkingV1ServiceCIDRStatus", + method = "PUT", + path = "/apis/networking.k8s.io/v1/servicecidrs/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNetworkingV1ServiceCIDR, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1servicecidrs~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenetworkingv1servicecidrstatus(...)\n\nreplace status of the specified ServiceCIDR\n\n`PUT /apis/networking.k8s.io/v1/servicecidrs/{name}/status`" +function replacenetworkingv1servicecidrstatus(name::String, body::IoK8sApiNetworkingV1ServiceCIDR; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenetworkingv1servicecidrstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1ingressclasslist = ( + id = "watchNetworkingV1IngressClassList", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/ingressclasses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1ingressclasslist(...)\n\nwatch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/ingressclasses`" +function watchnetworkingv1ingressclasslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1ingressclasslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1ingressclass = ( + id = "watchNetworkingV1IngressClass", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/ingressclasses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingressclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1ingressclass(...)\n\nwatch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/networking.k8s.io/v1/watch/ingressclasses/{name}`" +function watchnetworkingv1ingressclass(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1ingressclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1ingresslistforallnamespaces = ( + id = "watchNetworkingV1IngressListForAllNamespaces", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/ingresses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ingresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1ingresslistforallnamespaces(...)\n\nwatch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/ingresses`" +function watchnetworkingv1ingresslistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1ingresslistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1ipaddresslist = ( + id = "watchNetworkingV1IPAddressList", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/ipaddresses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1ipaddresslist(...)\n\nwatch individual changes to a list of IPAddress. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/ipaddresses`" +function watchnetworkingv1ipaddresslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1ipaddresslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1ipaddress = ( + id = "watchNetworkingV1IPAddress", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/ipaddresses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1ipaddresses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1ipaddress(...)\n\nwatch changes to an object of kind IPAddress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/networking.k8s.io/v1/watch/ipaddresses/{name}`" +function watchnetworkingv1ipaddress(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1ipaddress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1namespacedingresslist = ( + id = "watchNetworkingV1NamespacedIngressList", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1namespacedingresslist(...)\n\nwatch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses`" +function watchnetworkingv1namespacedingresslist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1namespacedingresslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1namespacedingress = ( + id = "watchNetworkingV1NamespacedIngress", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1ingresses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1namespacedingress(...)\n\nwatch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}`" +function watchnetworkingv1namespacedingress(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1namespacedingress, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1namespacednetworkpolicylist = ( + id = "watchNetworkingV1NamespacedNetworkPolicyList", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1namespacednetworkpolicylist(...)\n\nwatch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies`" +function watchnetworkingv1namespacednetworkpolicylist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1namespacednetworkpolicylist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1namespacednetworkpolicy = ( + id = "watchNetworkingV1NamespacedNetworkPolicy", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1namespaces~1{namespace}~1networkpolicies~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1namespacednetworkpolicy(...)\n\nwatch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}`" +function watchnetworkingv1namespacednetworkpolicy(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1namespacednetworkpolicy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1networkpolicylistforallnamespaces = ( + id = "watchNetworkingV1NetworkPolicyListForAllNamespaces", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/networkpolicies", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1networkpolicies/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1networkpolicylistforallnamespaces(...)\n\nwatch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/networkpolicies`" +function watchnetworkingv1networkpolicylistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1networkpolicylistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1servicecidrlist = ( + id = "watchNetworkingV1ServiceCIDRList", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/servicecidrs", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1servicecidrlist(...)\n\nwatch individual changes to a list of ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/networking.k8s.io/v1/watch/servicecidrs`" +function watchnetworkingv1servicecidrlist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1servicecidrlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnetworkingv1servicecidr = ( + id = "watchNetworkingV1ServiceCIDR", + method = "GET", + path = "/apis/networking.k8s.io/v1/watch/servicecidrs/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-7c11a0514645f836457f.json", pointer = "/paths/~1apis~1networking.k8s.io~1v1~1watch~1servicecidrs~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnetworkingv1servicecidr(...)\n\nwatch changes to an object of kind ServiceCIDR. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/networking.k8s.io/v1/watch/servicecidrs/{name}`" +function watchnetworkingv1servicecidr(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnetworkingv1servicecidr, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sNetworkingK8sIoV1 diff --git a/src/ApiImpl/generated/K8sNodeK8sIoV1.jl b/src/ApiImpl/generated/K8sNodeK8sIoV1.jl new file mode 100644 index 00000000..e2029445 --- /dev/null +++ b/src/ApiImpl/generated/K8sNodeK8sIoV1.jl @@ -0,0 +1,1646 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sNodeK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", retrieval = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.core.v1.Toleration\":{\"description\":\"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .\",\"properties\":{\"effect\":{\"description\":\"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\",\"type\":\"string\"},\"key\":{\"description\":\"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.\",\"type\":\"string\"},\"operator\":{\"description\":\"Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).\",\"type\":\"string\"},\"tolerationSeconds\":{\"description\":\"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.\",\"format\":\"int64\",\"type\":\"integer\"},\"value\":{\"description\":\"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.node.v1.Overhead\":{\"description\":\"Overhead structure represents the resource overhead associated with running a pod.\",\"properties\":{\"podFixed\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"podFixed represents the fixed resource overhead associated with running a pod.\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.node.v1.RuntimeClass\":{\"description\":\"RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"handler\":{\"default\":\"\",\"description\":\"handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called \\\"runc\\\" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"overhead\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.Overhead\"},\"scheduling\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.Scheduling\"}},\"required\":[\"handler\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}]},\"io.k8s.api.node.v1.RuntimeClassList\":{\"description\":\"RuntimeClassList is a list of RuntimeClass objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of schema objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClassList\",\"version\":\"v1\"}]},\"io.k8s.api.node.v1.Scheduling\":{\"description\":\"Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.\",\"properties\":{\"nodeSelector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"tolerations\":{\"description\":\"tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.core.v1.Toleration\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/node.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getNodeV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"]}},\"/apis/node.k8s.io/v1/runtimeclasses\":{\"delete\":{\"description\":\"delete collection of RuntimeClass\",\"operationId\":\"deleteNodeV1CollectionRuntimeClass\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind RuntimeClass\",\"operationId\":\"listNodeV1RuntimeClass\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClassList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a RuntimeClass\",\"operationId\":\"createNodeV1RuntimeClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}}},\"/apis/node.k8s.io/v1/runtimeclasses/{name}\":{\"delete\":{\"description\":\"delete a RuntimeClass\",\"operationId\":\"deleteNodeV1RuntimeClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified RuntimeClass\",\"operationId\":\"readNodeV1RuntimeClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the RuntimeClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified RuntimeClass\",\"operationId\":\"patchNodeV1RuntimeClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified RuntimeClass\",\"operationId\":\"replaceNodeV1RuntimeClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.api.node.v1.RuntimeClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}}},\"/apis/node.k8s.io/v1/watch/runtimeclasses\":{\"get\":{\"description\":\"watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchNodeV1RuntimeClassList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/node.k8s.io/v1/watch/runtimeclasses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchNodeV1RuntimeClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-18ba710a37d4362f1945.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"node_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"node.k8s.io\",\"kind\":\"RuntimeClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the RuntimeClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Overhead", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClass", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClassList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Scheduling", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiCoreV1Toleration + effect::Union{Absent,Nothing,String} = ABSENT + key::Union{Absent,Nothing,String} = ABSENT + operator::Union{Absent,Nothing,String} = ABSENT + tolerationseconds::Union{Absent,Int64,Nothing} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Toleration}, value) = _decode(IoK8sApiCoreV1Toleration, value, true) +function _decode(::Type{IoK8sApiCoreV1Toleration}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_raw, "decoding IoK8sApiCoreV1Toleration"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Toleration") + _openapi_field_effect = haskey(_openapi_object, "effect") ? _decode(Union{Absent,Nothing,String}, _openapi_object["effect"], _openapi_validate) : ABSENT + _openapi_field_key = haskey(_openapi_object, "key") ? _decode(Union{Absent,Nothing,String}, _openapi_object["key"], _openapi_validate) : ABSENT + _openapi_field_operator = haskey(_openapi_object, "operator") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operator"], _openapi_validate) : ABSENT + _openapi_field_tolerationseconds = haskey(_openapi_object, "tolerationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["tolerationSeconds"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("effect","key","operator","tolerationSeconds","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Toleration(; effect = _openapi_field_effect, key = _openapi_field_key, operator = _openapi_field_operator, tolerationseconds = _openapi_field_tolerationseconds, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.effect isa Absent || (_openapi_output["effect"] = _encode(_openapi_value.effect)) + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.tolerationseconds isa Absent || (_openapi_output["tolerationSeconds"] = _encode(_openapi_value.tolerationseconds)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_output, "encoding IoK8sApiCoreV1Toleration"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = Pair{String,Any}[] + _openapi_value.effect isa Absent || push!(_openapi_output, "effect" => _openapi_value.effect) + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.tolerationseconds isa Absent || push!(_openapi_output, "tolerationSeconds" => _openapi_value.tolerationseconds) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiNodeV1OverheadPodFixed + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiNodeV1OverheadPodFixed}, value) = _decode(IoK8sApiNodeV1OverheadPodFixed, value, true) +function _decode(::Type{IoK8sApiNodeV1OverheadPodFixed}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Overhead/properties/podFixed"), _openapi_raw, "decoding IoK8sApiNodeV1OverheadPodFixed"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1OverheadPodFixed") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1OverheadPodFixed(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1OverheadPodFixed) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Overhead/properties/podFixed"), _openapi_output, "encoding IoK8sApiNodeV1OverheadPodFixed"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1OverheadPodFixed) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNodeV1Overhead + podfixed::Union{Absent,IoK8sApiNodeV1OverheadPodFixed,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNodeV1Overhead}, value) = _decode(IoK8sApiNodeV1Overhead, value, true) +function _decode(::Type{IoK8sApiNodeV1Overhead}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Overhead"), _openapi_raw, "decoding IoK8sApiNodeV1Overhead"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1Overhead") + _openapi_field_podfixed = haskey(_openapi_object, "podFixed") ? _decode(Union{Absent,IoK8sApiNodeV1OverheadPodFixed,Nothing}, _openapi_object["podFixed"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("podFixed",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1Overhead(; podfixed = _openapi_field_podfixed, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1Overhead) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.podfixed isa Absent || (_openapi_output["podFixed"] = _encode(_openapi_value.podfixed)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Overhead"), _openapi_output, "encoding IoK8sApiNodeV1Overhead"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1Overhead) + _openapi_output = Pair{String,Any}[] + _openapi_value.podfixed isa Absent || push!(_openapi_output, "podFixed" => _openapi_value.podfixed) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNodeV1SchedulingNodeSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiNodeV1SchedulingNodeSelector}, value) = _decode(IoK8sApiNodeV1SchedulingNodeSelector, value, true) +function _decode(::Type{IoK8sApiNodeV1SchedulingNodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Scheduling/properties/nodeSelector"), _openapi_raw, "decoding IoK8sApiNodeV1SchedulingNodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1SchedulingNodeSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1SchedulingNodeSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1SchedulingNodeSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Scheduling/properties/nodeSelector"), _openapi_output, "encoding IoK8sApiNodeV1SchedulingNodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1SchedulingNodeSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNodeV1Scheduling + nodeselector::Union{Absent,IoK8sApiNodeV1SchedulingNodeSelector,Nothing} = ABSENT + tolerations::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNodeV1Scheduling}, value) = _decode(IoK8sApiNodeV1Scheduling, value, true) +function _decode(::Type{IoK8sApiNodeV1Scheduling}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Scheduling"), _openapi_raw, "decoding IoK8sApiNodeV1Scheduling"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1Scheduling") + _openapi_field_nodeselector = haskey(_openapi_object, "nodeSelector") ? _decode(Union{Absent,IoK8sApiNodeV1SchedulingNodeSelector,Nothing}, _openapi_object["nodeSelector"], _openapi_validate) : ABSENT + _openapi_field_tolerations = haskey(_openapi_object, "tolerations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}}, _openapi_object["tolerations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeSelector","tolerations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1Scheduling(; nodeselector = _openapi_field_nodeselector, tolerations = _openapi_field_tolerations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1Scheduling) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeselector isa Absent || (_openapi_output["nodeSelector"] = _encode(_openapi_value.nodeselector)) + _openapi_value.tolerations isa Absent || (_openapi_output["tolerations"] = _encode(_openapi_value.tolerations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.Scheduling"), _openapi_output, "encoding IoK8sApiNodeV1Scheduling"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1Scheduling) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeselector isa Absent || push!(_openapi_output, "nodeSelector" => _openapi_value.nodeselector) + _openapi_value.tolerations isa Absent || push!(_openapi_output, "tolerations" => _openapi_value.tolerations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNodeV1RuntimeClass + apiversion::Union{Absent,Nothing,String} = ABSENT + handler::String + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + overhead::Union{Absent,IoK8sApiNodeV1Overhead,Nothing} = ABSENT + scheduling::Union{Absent,IoK8sApiNodeV1Scheduling,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNodeV1RuntimeClass}, value) = _decode(IoK8sApiNodeV1RuntimeClass, value, true) +function _decode(::Type{IoK8sApiNodeV1RuntimeClass}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClass"), _openapi_raw, "decoding IoK8sApiNodeV1RuntimeClass"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1RuntimeClass") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_handler = _decode(String, _required(_openapi_object, "handler", "IoK8sApiNodeV1RuntimeClass"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_overhead = haskey(_openapi_object, "overhead") ? _decode(Union{Absent,IoK8sApiNodeV1Overhead,Nothing}, _openapi_object["overhead"], _openapi_validate) : ABSENT + _openapi_field_scheduling = haskey(_openapi_object, "scheduling") ? _decode(Union{Absent,IoK8sApiNodeV1Scheduling,Nothing}, _openapi_object["scheduling"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","handler","kind","metadata","overhead","scheduling") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1RuntimeClass(; apiversion = _openapi_field_apiversion, handler = _openapi_field_handler, kind = _openapi_field_kind, metadata = _openapi_field_metadata, overhead = _openapi_field_overhead, scheduling = _openapi_field_scheduling, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1RuntimeClass) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.handler isa Absent || (_openapi_output["handler"] = _encode(_openapi_value.handler)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.overhead isa Absent || (_openapi_output["overhead"] = _encode(_openapi_value.overhead)) + _openapi_value.scheduling isa Absent || (_openapi_output["scheduling"] = _encode(_openapi_value.scheduling)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClass"), _openapi_output, "encoding IoK8sApiNodeV1RuntimeClass"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1RuntimeClass) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.handler isa Absent || push!(_openapi_output, "handler" => _openapi_value.handler) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.overhead isa Absent || push!(_openapi_output, "overhead" => _openapi_value.overhead) + _openapi_value.scheduling isa Absent || push!(_openapi_output, "scheduling" => _openapi_value.scheduling) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiNodeV1RuntimeClassList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiNodeV1RuntimeClass}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiNodeV1RuntimeClassList}, value) = _decode(IoK8sApiNodeV1RuntimeClassList, value, true) +function _decode(::Type{IoK8sApiNodeV1RuntimeClassList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClassList"), _openapi_raw, "decoding IoK8sApiNodeV1RuntimeClassList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiNodeV1RuntimeClassList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiNodeV1RuntimeClass}}, _required(_openapi_object, "items", "IoK8sApiNodeV1RuntimeClassList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiNodeV1RuntimeClassList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiNodeV1RuntimeClassList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.api.node.v1.RuntimeClassList"), _openapi_output, "encoding IoK8sApiNodeV1RuntimeClassList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiNodeV1RuntimeClassList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getnodev1apiresources = ( + id = "getNodeV1APIResources", + method = "GET", + path = "/apis/node.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getnodev1apiresources(...)\n\nget available resources\n\n`GET /apis/node.k8s.io/v1/`" +function getnodev1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getnodev1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenodev1collectionruntimeclass = ( + id = "deleteNodeV1CollectionRuntimeClass", + method = "DELETE", + path = "/apis/node.k8s.io/v1/runtimeclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenodev1collectionruntimeclass(...)\n\ndelete collection of RuntimeClass\n\n`DELETE /apis/node.k8s.io/v1/runtimeclasses`" +function deletenodev1collectionruntimeclass(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletenodev1collectionruntimeclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listnodev1runtimeclass = ( + id = "listNodeV1RuntimeClass", + method = "GET", + path = "/apis/node.k8s.io/v1/runtimeclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClassList, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listnodev1runtimeclass(...)\n\nlist or watch objects of kind RuntimeClass\n\n`GET /apis/node.k8s.io/v1/runtimeclasses`" +function listnodev1runtimeclass(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listnodev1runtimeclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createnodev1runtimeclass = ( + id = "createNodeV1RuntimeClass", + method = "POST", + path = "/apis/node.k8s.io/v1/runtimeclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createnodev1runtimeclass(...)\n\ncreate a RuntimeClass\n\n`POST /apis/node.k8s.io/v1/runtimeclasses`" +function createnodev1runtimeclass(body::IoK8sApiNodeV1RuntimeClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createnodev1runtimeclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletenodev1runtimeclass = ( + id = "deleteNodeV1RuntimeClass", + method = "DELETE", + path = "/apis/node.k8s.io/v1/runtimeclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletenodev1runtimeclass(...)\n\ndelete a RuntimeClass\n\n`DELETE /apis/node.k8s.io/v1/runtimeclasses/{name}`" +function deletenodev1runtimeclass(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletenodev1runtimeclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readnodev1runtimeclass = ( + id = "readNodeV1RuntimeClass", + method = "GET", + path = "/apis/node.k8s.io/v1/runtimeclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readnodev1runtimeclass(...)\n\nread the specified RuntimeClass\n\n`GET /apis/node.k8s.io/v1/runtimeclasses/{name}`" +function readnodev1runtimeclass(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readnodev1runtimeclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchnodev1runtimeclass = ( + id = "patchNodeV1RuntimeClass", + method = "PATCH", + path = "/apis/node.k8s.io/v1/runtimeclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchnodev1runtimeclass(...)\n\npartially update the specified RuntimeClass\n\n`PATCH /apis/node.k8s.io/v1/runtimeclasses/{name}`" +function patchnodev1runtimeclass(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchnodev1runtimeclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacenodev1runtimeclass = ( + id = "replaceNodeV1RuntimeClass", + method = "PUT", + path = "/apis/node.k8s.io/v1/runtimeclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiNodeV1RuntimeClass, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1runtimeclasses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacenodev1runtimeclass(...)\n\nreplace the specified RuntimeClass\n\n`PUT /apis/node.k8s.io/v1/runtimeclasses/{name}`" +function replacenodev1runtimeclass(name::String, body::IoK8sApiNodeV1RuntimeClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacenodev1runtimeclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnodev1runtimeclasslist = ( + id = "watchNodeV1RuntimeClassList", + method = "GET", + path = "/apis/node.k8s.io/v1/watch/runtimeclasses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnodev1runtimeclasslist(...)\n\nwatch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/node.k8s.io/v1/watch/runtimeclasses`" +function watchnodev1runtimeclasslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnodev1runtimeclasslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchnodev1runtimeclass = ( + id = "watchNodeV1RuntimeClass", + method = "GET", + path = "/apis/node.k8s.io/v1/watch/runtimeclasses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-18ba710a37d4362f1945.json", pointer = "/paths/~1apis~1node.k8s.io~1v1~1watch~1runtimeclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchnodev1runtimeclass(...)\n\nwatch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/node.k8s.io/v1/watch/runtimeclasses/{name}`" +function watchnodev1runtimeclass(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchnodev1runtimeclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sNodeK8sIoV1 diff --git a/src/ApiImpl/generated/K8sPolicyV1.jl b/src/ApiImpl/generated/K8sPolicyV1.jl new file mode 100644 index 00000000..76b3c8d4 --- /dev/null +++ b/src/ApiImpl/generated/K8sPolicyV1.jl @@ -0,0 +1,1983 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sPolicyV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", retrieval = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.policy.v1.PodDisruptionBudget\":{\"description\":\"PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}]},\"io.k8s.api.policy.v1.PodDisruptionBudgetList\":{\"description\":\"PodDisruptionBudgetList is a collection of PodDisruptionBudgets.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of PodDisruptionBudgets\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"policy\",\"kind\":\"PodDisruptionBudgetList\",\"version\":\"v1\"}]},\"io.k8s.api.policy.v1.PodDisruptionBudgetSpec\":{\"description\":\"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.\",\"properties\":{\"maxUnavailable\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"minAvailable\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"unhealthyPodEvictionPolicy\":{\"description\":\"UnhealthyPodEvictionPolicy defines the criteria for when unhealthy pods should be considered for eviction. Current implementation considers healthy pods, as pods that have status.conditions item with type=\\\"Ready\\\",status=\\\"True\\\".\\n\\nValid policies are IfHealthyBudget and AlwaysAllow. If no policy is specified, the default behavior will be used, which corresponds to the IfHealthyBudget policy.\\n\\nIfHealthyBudget policy means that running pods (status.phase=\\\"Running\\\"), but not yet healthy can be evicted only if the guarded application is not disrupted (status.currentHealthy is at least equal to status.desiredHealthy). Healthy pods will be subject to the PDB for eviction.\\n\\nAlwaysAllow policy means that all running pods (status.phase=\\\"Running\\\"), but not yet healthy are considered disrupted and can be evicted regardless of whether the criteria in a PDB is met. This means perspective running pods of a disrupted application might not get a chance to become healthy. Healthy pods will be subject to the PDB for eviction.\\n\\nAdditional policies may be added in the future. Clients making eviction decisions should disallow eviction of unhealthy pods if they encounter an unrecognized policy in this field.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.policy.v1.PodDisruptionBudgetStatus\":{\"description\":\"PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.\",\"properties\":{\"conditions\":{\"description\":\"Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute\\n the number of allowed disruptions. Therefore no disruptions are\\n allowed and the status of the condition will be False.\\n- InsufficientPods: The number of pods are either at or below the number\\n required by the PodDisruptionBudget. No disruptions are\\n allowed and the status of the condition will be False.\\n- SufficientPods: There are more pods than required by the PodDisruptionBudget.\\n The condition will be True, and the number of allowed\\n disruptions are provided by the disruptionsAllowed property.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentHealthy\":{\"default\":0,\"description\":\"current number of healthy pods\",\"format\":\"int32\",\"type\":\"integer\"},\"desiredHealthy\":{\"default\":0,\"description\":\"minimum desired number of healthy pods\",\"format\":\"int32\",\"type\":\"integer\"},\"disruptedPods\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"description\":\"DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions.\",\"type\":\"object\"},\"disruptionsAllowed\":{\"default\":0,\"description\":\"Number of pod disruptions that are currently allowed.\",\"format\":\"int32\",\"type\":\"integer\"},\"expectedPods\":{\"default\":0,\"description\":\"total number of pods counted by this disruption budget\",\"format\":\"int32\",\"type\":\"integer\"},\"observedGeneration\":{\"description\":\"Most recent generation observed when updating this PDB status. DisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"disruptionsAllowed\",\"currentHealthy\",\"desiredHealthy\",\"expectedPods\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.Condition\":{\"description\":\"Condition contains details for one aspect of the current state of this API Resource.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"default\":\"\",\"description\":\"message is a human readable message indicating details about the transition. This may be an empty string.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.\",\"format\":\"int64\",\"type\":\"integer\"},\"reason\":{\"default\":\"\",\"description\":\"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type of condition in CamelCase or in foo.example.com/CamelCase.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\",\"lastTransitionTime\",\"reason\",\"message\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.util.intstr.IntOrString\":{\"description\":\"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.\",\"format\":\"int-or-string\",\"oneOf\":[{\"type\":\"integer\"},{\"type\":\"string\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/policy/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getPolicyV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"]}},\"/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets\":{\"delete\":{\"description\":\"delete collection of PodDisruptionBudget\",\"operationId\":\"deletePolicyV1CollectionNamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind PodDisruptionBudget\",\"operationId\":\"listPolicyV1NamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a PodDisruptionBudget\",\"operationId\":\"createPolicyV1NamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}}},\"/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}\":{\"delete\":{\"description\":\"delete a PodDisruptionBudget\",\"operationId\":\"deletePolicyV1NamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified PodDisruptionBudget\",\"operationId\":\"readPolicyV1NamespacedPodDisruptionBudget\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the PodDisruptionBudget\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified PodDisruptionBudget\",\"operationId\":\"patchPolicyV1NamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified PodDisruptionBudget\",\"operationId\":\"replacePolicyV1NamespacedPodDisruptionBudget\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}}},\"/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status\":{\"get\":{\"description\":\"read status of the specified PodDisruptionBudget\",\"operationId\":\"readPolicyV1NamespacedPodDisruptionBudgetStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PodDisruptionBudget\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified PodDisruptionBudget\",\"operationId\":\"patchPolicyV1NamespacedPodDisruptionBudgetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified PodDisruptionBudget\",\"operationId\":\"replacePolicyV1NamespacedPodDisruptionBudgetStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}}},\"/apis/policy/v1/poddisruptionbudgets\":{\"get\":{\"description\":\"list or watch objects of kind PodDisruptionBudget\",\"operationId\":\"listPolicyV1PodDisruptionBudgetForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets\":{\"get\":{\"description\":\"watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchPolicyV1NamespacedPodDisruptionBudgetList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchPolicyV1NamespacedPodDisruptionBudget\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the PodDisruptionBudget\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/policy/v1/watch/poddisruptionbudgets\":{\"get\":{\"description\":\"watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchPolicyV1PodDisruptionBudgetListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-61cda00600e081e79bdc.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"policy_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"PodDisruptionBudget\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgUtilIntstrIntOrString + value::Union{Int64,String} +end +_decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value) = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, value, true) +function _decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), value, "decoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(Int64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgUtilIntstrIntOrString")) + return IoK8sApimachineryPkgUtilIntstrIntOrString(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgUtilIntstrIntOrString) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), output, "encoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1PodDisruptionBudgetSpec + maxunavailable::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + minavailable::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + unhealthypodevictionpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetSpec}, value) = _decode(IoK8sApiPolicyV1PodDisruptionBudgetSpec, value, true) +function _decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec"), _openapi_raw, "decoding IoK8sApiPolicyV1PodDisruptionBudgetSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1PodDisruptionBudgetSpec") + _openapi_field_maxunavailable = haskey(_openapi_object, "maxUnavailable") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["maxUnavailable"], _openapi_validate) : ABSENT + _openapi_field_minavailable = haskey(_openapi_object, "minAvailable") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["minAvailable"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_unhealthypodevictionpolicy = haskey(_openapi_object, "unhealthyPodEvictionPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["unhealthyPodEvictionPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("maxUnavailable","minAvailable","selector","unhealthyPodEvictionPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1PodDisruptionBudgetSpec(; maxunavailable = _openapi_field_maxunavailable, minavailable = _openapi_field_minavailable, selector = _openapi_field_selector, unhealthypodevictionpolicy = _openapi_field_unhealthypodevictionpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.maxunavailable isa Absent || (_openapi_output["maxUnavailable"] = _encode(_openapi_value.maxunavailable)) + _openapi_value.minavailable isa Absent || (_openapi_output["minAvailable"] = _encode(_openapi_value.minavailable)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.unhealthypodevictionpolicy isa Absent || (_openapi_output["unhealthyPodEvictionPolicy"] = _encode(_openapi_value.unhealthypodevictionpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetSpec"), _openapi_output, "encoding IoK8sApiPolicyV1PodDisruptionBudgetSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.maxunavailable isa Absent || push!(_openapi_output, "maxUnavailable" => _openapi_value.maxunavailable) + _openapi_value.minavailable isa Absent || push!(_openapi_output, "minAvailable" => _openapi_value.minavailable) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.unhealthypodevictionpolicy isa Absent || push!(_openapi_output, "unhealthyPodEvictionPolicy" => _openapi_value.unhealthypodevictionpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Condition + lasttransitiontime::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + message::String + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + reason::String + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Condition, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Condition") + _openapi_field_lasttransitiontime = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "lastTransitionTime", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_message = _decode(String, _required(_openapi_object, "message", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_reason = _decode(String, _required(_openapi_object, "reason", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","observedGeneration","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Condition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, observedgeneration = _openapi_field_observedgeneration, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods + additional_properties::Dict{String,IoK8sApimachineryPkgApisMetaV1Time} = Dict{String,IoK8sApimachineryPkgApisMetaV1Time}() +end +_decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods}, value) = _decode(IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods, value, true) +function _decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus/properties/disruptedPods"), _openapi_raw, "decoding IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApisMetaV1Time}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApisMetaV1Time, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus/properties/disruptedPods"), _openapi_output, "encoding IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1PodDisruptionBudgetStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}} = ABSENT + currenthealthy::Int32 + desiredhealthy::Int32 + disruptedpods::Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods,Nothing} = ABSENT + disruptionsallowed::Int32 + expectedpods::Int32 + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetStatus}, value) = _decode(IoK8sApiPolicyV1PodDisruptionBudgetStatus, value, true) +function _decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus"), _openapi_raw, "decoding IoK8sApiPolicyV1PodDisruptionBudgetStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1PodDisruptionBudgetStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currenthealthy = _decode(Int32, _required(_openapi_object, "currentHealthy", "IoK8sApiPolicyV1PodDisruptionBudgetStatus"), _openapi_validate) + _openapi_field_desiredhealthy = _decode(Int32, _required(_openapi_object, "desiredHealthy", "IoK8sApiPolicyV1PodDisruptionBudgetStatus"), _openapi_validate) + _openapi_field_disruptedpods = haskey(_openapi_object, "disruptedPods") ? _decode(Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetStatusDisruptedPods,Nothing}, _openapi_object["disruptedPods"], _openapi_validate) : ABSENT + _openapi_field_disruptionsallowed = _decode(Int32, _required(_openapi_object, "disruptionsAllowed", "IoK8sApiPolicyV1PodDisruptionBudgetStatus"), _openapi_validate) + _openapi_field_expectedpods = _decode(Int32, _required(_openapi_object, "expectedPods", "IoK8sApiPolicyV1PodDisruptionBudgetStatus"), _openapi_validate) + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions","currentHealthy","desiredHealthy","disruptedPods","disruptionsAllowed","expectedPods","observedGeneration") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1PodDisruptionBudgetStatus(; conditions = _openapi_field_conditions, currenthealthy = _openapi_field_currenthealthy, desiredhealthy = _openapi_field_desiredhealthy, disruptedpods = _openapi_field_disruptedpods, disruptionsallowed = _openapi_field_disruptionsallowed, expectedpods = _openapi_field_expectedpods, observedgeneration = _openapi_field_observedgeneration, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currenthealthy isa Absent || (_openapi_output["currentHealthy"] = _encode(_openapi_value.currenthealthy)) + _openapi_value.desiredhealthy isa Absent || (_openapi_output["desiredHealthy"] = _encode(_openapi_value.desiredhealthy)) + _openapi_value.disruptedpods isa Absent || (_openapi_output["disruptedPods"] = _encode(_openapi_value.disruptedpods)) + _openapi_value.disruptionsallowed isa Absent || (_openapi_output["disruptionsAllowed"] = _encode(_openapi_value.disruptionsallowed)) + _openapi_value.expectedpods isa Absent || (_openapi_output["expectedPods"] = _encode(_openapi_value.expectedpods)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetStatus"), _openapi_output, "encoding IoK8sApiPolicyV1PodDisruptionBudgetStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currenthealthy isa Absent || push!(_openapi_output, "currentHealthy" => _openapi_value.currenthealthy) + _openapi_value.desiredhealthy isa Absent || push!(_openapi_output, "desiredHealthy" => _openapi_value.desiredhealthy) + _openapi_value.disruptedpods isa Absent || push!(_openapi_output, "disruptedPods" => _openapi_value.disruptedpods) + _openapi_value.disruptionsallowed isa Absent || push!(_openapi_output, "disruptionsAllowed" => _openapi_value.disruptionsallowed) + _openapi_value.expectedpods isa Absent || push!(_openapi_output, "expectedPods" => _openapi_value.expectedpods) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1PodDisruptionBudget + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiPolicyV1PodDisruptionBudget}, value) = _decode(IoK8sApiPolicyV1PodDisruptionBudget, value, true) +function _decode(::Type{IoK8sApiPolicyV1PodDisruptionBudget}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget"), _openapi_raw, "decoding IoK8sApiPolicyV1PodDisruptionBudget"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1PodDisruptionBudget") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiPolicyV1PodDisruptionBudgetStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1PodDisruptionBudget(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudget) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudget"), _openapi_output, "encoding IoK8sApiPolicyV1PodDisruptionBudget"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudget) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1PodDisruptionBudgetList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiPolicyV1PodDisruptionBudget}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetList}, value) = _decode(IoK8sApiPolicyV1PodDisruptionBudgetList, value, true) +function _decode(::Type{IoK8sApiPolicyV1PodDisruptionBudgetList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList"), _openapi_raw, "decoding IoK8sApiPolicyV1PodDisruptionBudgetList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1PodDisruptionBudgetList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiPolicyV1PodDisruptionBudget}}, _required(_openapi_object, "items", "IoK8sApiPolicyV1PodDisruptionBudgetList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1PodDisruptionBudgetList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.api.policy.v1.PodDisruptionBudgetList"), _openapi_output, "encoding IoK8sApiPolicyV1PodDisruptionBudgetList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1PodDisruptionBudgetList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getpolicyv1apiresources = ( + id = "getPolicyV1APIResources", + method = "GET", + path = "/apis/policy/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getpolicyv1apiresources(...)\n\nget available resources\n\n`GET /apis/policy/v1/`" +function getpolicyv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getpolicyv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletepolicyv1collectionnamespacedpoddisruptionbudget = ( + id = "deletePolicyV1CollectionNamespacedPodDisruptionBudget", + method = "DELETE", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletepolicyv1collectionnamespacedpoddisruptionbudget(...)\n\ndelete collection of PodDisruptionBudget\n\n`DELETE /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets`" +function deletepolicyv1collectionnamespacedpoddisruptionbudget(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletepolicyv1collectionnamespacedpoddisruptionbudget, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listpolicyv1namespacedpoddisruptionbudget = ( + id = "listPolicyV1NamespacedPodDisruptionBudget", + method = "GET", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listpolicyv1namespacedpoddisruptionbudget(...)\n\nlist or watch objects of kind PodDisruptionBudget\n\n`GET /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets`" +function listpolicyv1namespacedpoddisruptionbudget(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listpolicyv1namespacedpoddisruptionbudget, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createpolicyv1namespacedpoddisruptionbudget = ( + id = "createPolicyV1NamespacedPodDisruptionBudget", + method = "POST", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createpolicyv1namespacedpoddisruptionbudget(...)\n\ncreate a PodDisruptionBudget\n\n`POST /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets`" +function createpolicyv1namespacedpoddisruptionbudget(namespace::String, body::IoK8sApiPolicyV1PodDisruptionBudget; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createpolicyv1namespacedpoddisruptionbudget, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletepolicyv1namespacedpoddisruptionbudget = ( + id = "deletePolicyV1NamespacedPodDisruptionBudget", + method = "DELETE", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletepolicyv1namespacedpoddisruptionbudget(...)\n\ndelete a PodDisruptionBudget\n\n`DELETE /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}`" +function deletepolicyv1namespacedpoddisruptionbudget(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletepolicyv1namespacedpoddisruptionbudget, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readpolicyv1namespacedpoddisruptionbudget = ( + id = "readPolicyV1NamespacedPodDisruptionBudget", + method = "GET", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readpolicyv1namespacedpoddisruptionbudget(...)\n\nread the specified PodDisruptionBudget\n\n`GET /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}`" +function readpolicyv1namespacedpoddisruptionbudget(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readpolicyv1namespacedpoddisruptionbudget, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchpolicyv1namespacedpoddisruptionbudget = ( + id = "patchPolicyV1NamespacedPodDisruptionBudget", + method = "PATCH", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchpolicyv1namespacedpoddisruptionbudget(...)\n\npartially update the specified PodDisruptionBudget\n\n`PATCH /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}`" +function patchpolicyv1namespacedpoddisruptionbudget(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchpolicyv1namespacedpoddisruptionbudget, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacepolicyv1namespacedpoddisruptionbudget = ( + id = "replacePolicyV1NamespacedPodDisruptionBudget", + method = "PUT", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacepolicyv1namespacedpoddisruptionbudget(...)\n\nreplace the specified PodDisruptionBudget\n\n`PUT /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}`" +function replacepolicyv1namespacedpoddisruptionbudget(namespace::String, name::String, body::IoK8sApiPolicyV1PodDisruptionBudget; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacepolicyv1namespacedpoddisruptionbudget, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readpolicyv1namespacedpoddisruptionbudgetstatus = ( + id = "readPolicyV1NamespacedPodDisruptionBudgetStatus", + method = "GET", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readpolicyv1namespacedpoddisruptionbudgetstatus(...)\n\nread status of the specified PodDisruptionBudget\n\n`GET /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status`" +function readpolicyv1namespacedpoddisruptionbudgetstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readpolicyv1namespacedpoddisruptionbudgetstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchpolicyv1namespacedpoddisruptionbudgetstatus = ( + id = "patchPolicyV1NamespacedPodDisruptionBudgetStatus", + method = "PATCH", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchpolicyv1namespacedpoddisruptionbudgetstatus(...)\n\npartially update status of the specified PodDisruptionBudget\n\n`PATCH /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status`" +function patchpolicyv1namespacedpoddisruptionbudgetstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchpolicyv1namespacedpoddisruptionbudgetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacepolicyv1namespacedpoddisruptionbudgetstatus = ( + id = "replacePolicyV1NamespacedPodDisruptionBudgetStatus", + method = "PUT", + path = "/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudget, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacepolicyv1namespacedpoddisruptionbudgetstatus(...)\n\nreplace status of the specified PodDisruptionBudget\n\n`PUT /apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status`" +function replacepolicyv1namespacedpoddisruptionbudgetstatus(namespace::String, name::String, body::IoK8sApiPolicyV1PodDisruptionBudget; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacepolicyv1namespacedpoddisruptionbudgetstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listpolicyv1poddisruptionbudgetforallnamespaces = ( + id = "listPolicyV1PodDisruptionBudgetForAllNamespaces", + method = "GET", + path = "/apis/policy/v1/poddisruptionbudgets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1PodDisruptionBudgetList, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listpolicyv1poddisruptionbudgetforallnamespaces(...)\n\nlist or watch objects of kind PodDisruptionBudget\n\n`GET /apis/policy/v1/poddisruptionbudgets`" +function listpolicyv1poddisruptionbudgetforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listpolicyv1poddisruptionbudgetforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchpolicyv1namespacedpoddisruptionbudgetlist = ( + id = "watchPolicyV1NamespacedPodDisruptionBudgetList", + method = "GET", + path = "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchpolicyv1namespacedpoddisruptionbudgetlist(...)\n\nwatch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets`" +function watchpolicyv1namespacedpoddisruptionbudgetlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchpolicyv1namespacedpoddisruptionbudgetlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchpolicyv1namespacedpoddisruptionbudget = ( + id = "watchPolicyV1NamespacedPodDisruptionBudget", + method = "GET", + path = "/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1namespaces~1{namespace}~1poddisruptionbudgets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchpolicyv1namespacedpoddisruptionbudget(...)\n\nwatch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}`" +function watchpolicyv1namespacedpoddisruptionbudget(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchpolicyv1namespacedpoddisruptionbudget, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchpolicyv1poddisruptionbudgetlistforallnamespaces = ( + id = "watchPolicyV1PodDisruptionBudgetListForAllNamespaces", + method = "GET", + path = "/apis/policy/v1/watch/poddisruptionbudgets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-61cda00600e081e79bdc.json", pointer = "/paths/~1apis~1policy~1v1~1watch~1poddisruptionbudgets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchpolicyv1poddisruptionbudgetlistforallnamespaces(...)\n\nwatch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/policy/v1/watch/poddisruptionbudgets`" +function watchpolicyv1poddisruptionbudgetlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchpolicyv1poddisruptionbudgetlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sPolicyV1 diff --git a/src/ApiImpl/generated/K8sRbacAuthorizationK8sIoV1.jl b/src/ApiImpl/generated/K8sRbacAuthorizationK8sIoV1.jl new file mode 100644 index 00000000..c105c888 --- /dev/null +++ b/src/ApiImpl/generated/K8sRbacAuthorizationK8sIoV1.jl @@ -0,0 +1,3410 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sRbacAuthorizationK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", retrieval = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.rbac.v1.AggregationRule\":{\"description\":\"AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole\",\"properties\":{\"clusterRoleSelectors\":{\"description\":\"ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.rbac.v1.ClusterRole\":{\"description\":\"ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.\",\"properties\":{\"aggregationRule\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.AggregationRule\"},\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"rules\":{\"description\":\"Rules holds all the PolicyRules for this ClusterRole\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.PolicyRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.ClusterRoleBinding\":{\"description\":\"ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"roleRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleRef\"},\"subjects\":{\"description\":\"Subjects holds references to the objects the role applies to.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Subject\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"roleRef\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.ClusterRoleBindingList\":{\"description\":\"ClusterRoleBindingList is a collection of ClusterRoleBindings\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of ClusterRoleBindings\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBindingList\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.ClusterRoleList\":{\"description\":\"ClusterRoleList is a collection of ClusterRoles\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of ClusterRoles\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleList\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.PolicyRule\":{\"description\":\"PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.\",\"properties\":{\"apiGroups\":{\"description\":\"APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \\\"\\\" represents the core API group and \\\"*\\\" represents all API groups.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"nonResourceURLs\":{\"description\":\"NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \\\"pods\\\" or \\\"secrets\\\") or non-resource URL paths (such as \\\"/api\\\"), but not both.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resourceNames\":{\"description\":\"ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"description\":\"Resources is a list of resources this rule applies to. '*' represents all resources.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"verbs\":{\"description\":\"Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"verbs\"],\"type\":\"object\"},\"io.k8s.api.rbac.v1.Role\":{\"description\":\"Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"rules\":{\"description\":\"Rules holds all the PolicyRules for this Role\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.PolicyRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.RoleBinding\":{\"description\":\"RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"roleRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleRef\"},\"subjects\":{\"description\":\"Subjects holds references to the objects the role applies to.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Subject\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"roleRef\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.RoleBindingList\":{\"description\":\"RoleBindingList is a collection of RoleBindings\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of RoleBindings\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBindingList\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.RoleList\":{\"description\":\"RoleList is a collection of Roles\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of Roles\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleList\",\"version\":\"v1\"}]},\"io.k8s.api.rbac.v1.RoleRef\":{\"description\":\"RoleRef contains information that points to the role being used\",\"properties\":{\"apiGroup\":{\"default\":\"\",\"description\":\"APIGroup is the group for the resource being referenced\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"}},\"required\":[\"apiGroup\",\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.rbac.v1.Subject\":{\"description\":\"Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names.\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup holds the API group of the referenced subject. Defaults to \\\"\\\" for ServiceAccount subjects. Defaults to \\\"rbac.authorization.k8s.io\\\" for User and Group subjects.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of object being referenced. Values defined by this API group are \\\"User\\\", \\\"Group\\\", and \\\"ServiceAccount\\\". If the Authorizer does not recognized the kind value, the Authorizer should report an error.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the object being referenced.\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referenced object. If the object kind is non-namespace, such as \\\"User\\\" or \\\"Group\\\", and this value is not empty the Authorizer should report an error.\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/rbac.authorization.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getRbacAuthorizationV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"]}},\"/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\":{\"delete\":{\"description\":\"delete collection of ClusterRoleBinding\",\"operationId\":\"deleteRbacAuthorizationV1CollectionClusterRoleBinding\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ClusterRoleBinding\",\"operationId\":\"listRbacAuthorizationV1ClusterRoleBinding\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ClusterRoleBinding\",\"operationId\":\"createRbacAuthorizationV1ClusterRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}\":{\"delete\":{\"description\":\"delete a ClusterRoleBinding\",\"operationId\":\"deleteRbacAuthorizationV1ClusterRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ClusterRoleBinding\",\"operationId\":\"readRbacAuthorizationV1ClusterRoleBinding\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ClusterRoleBinding\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ClusterRoleBinding\",\"operationId\":\"patchRbacAuthorizationV1ClusterRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ClusterRoleBinding\",\"operationId\":\"replaceRbacAuthorizationV1ClusterRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/clusterroles\":{\"delete\":{\"description\":\"delete collection of ClusterRole\",\"operationId\":\"deleteRbacAuthorizationV1CollectionClusterRole\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ClusterRole\",\"operationId\":\"listRbacAuthorizationV1ClusterRole\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ClusterRole\",\"operationId\":\"createRbacAuthorizationV1ClusterRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}\":{\"delete\":{\"description\":\"delete a ClusterRole\",\"operationId\":\"deleteRbacAuthorizationV1ClusterRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ClusterRole\",\"operationId\":\"readRbacAuthorizationV1ClusterRole\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ClusterRole\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ClusterRole\",\"operationId\":\"patchRbacAuthorizationV1ClusterRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ClusterRole\",\"operationId\":\"replaceRbacAuthorizationV1ClusterRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.ClusterRole\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings\":{\"delete\":{\"description\":\"delete collection of RoleBinding\",\"operationId\":\"deleteRbacAuthorizationV1CollectionNamespacedRoleBinding\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind RoleBinding\",\"operationId\":\"listRbacAuthorizationV1NamespacedRoleBinding\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a RoleBinding\",\"operationId\":\"createRbacAuthorizationV1NamespacedRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}\":{\"delete\":{\"description\":\"delete a RoleBinding\",\"operationId\":\"deleteRbacAuthorizationV1NamespacedRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified RoleBinding\",\"operationId\":\"readRbacAuthorizationV1NamespacedRoleBinding\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the RoleBinding\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified RoleBinding\",\"operationId\":\"patchRbacAuthorizationV1NamespacedRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified RoleBinding\",\"operationId\":\"replaceRbacAuthorizationV1NamespacedRoleBinding\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBinding\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles\":{\"delete\":{\"description\":\"delete collection of Role\",\"operationId\":\"deleteRbacAuthorizationV1CollectionNamespacedRole\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Role\",\"operationId\":\"listRbacAuthorizationV1NamespacedRole\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Role\",\"operationId\":\"createRbacAuthorizationV1NamespacedRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}\":{\"delete\":{\"description\":\"delete a Role\",\"operationId\":\"deleteRbacAuthorizationV1NamespacedRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Role\",\"operationId\":\"readRbacAuthorizationV1NamespacedRole\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Role\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Role\",\"operationId\":\"patchRbacAuthorizationV1NamespacedRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Role\",\"operationId\":\"replaceRbacAuthorizationV1NamespacedRole\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.Role\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}}},\"/apis/rbac.authorization.k8s.io/v1/rolebindings\":{\"get\":{\"description\":\"list or watch objects of kind RoleBinding\",\"operationId\":\"listRbacAuthorizationV1RoleBindingForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleBindingList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/roles\":{\"get\":{\"description\":\"list or watch objects of kind Role\",\"operationId\":\"listRbacAuthorizationV1RoleForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.api.rbac.v1.RoleList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings\":{\"get\":{\"description\":\"watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1ClusterRoleBindingList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchRbacAuthorizationV1ClusterRoleBinding\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRoleBinding\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ClusterRoleBinding\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/clusterroles\":{\"get\":{\"description\":\"watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1ClusterRoleList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchRbacAuthorizationV1ClusterRole\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"ClusterRole\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ClusterRole\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings\":{\"get\":{\"description\":\"watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1NamespacedRoleBindingList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchRbacAuthorizationV1NamespacedRoleBinding\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the RoleBinding\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles\":{\"get\":{\"description\":\"watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1NamespacedRoleList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchRbacAuthorizationV1NamespacedRole\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Role\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/rolebindings\":{\"get\":{\"description\":\"watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1RoleBindingListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"RoleBinding\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/rbac.authorization.k8s.io/v1/watch/roles\":{\"get\":{\"description\":\"watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchRbacAuthorizationV1RoleListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-8d6c59100318f75600b3.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"rbacAuthorization_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.AggregationRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRole", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.PolicyRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Role", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBinding", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBindingList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleRef", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Subject", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1AggregationRule + clusterroleselectors::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1AggregationRule}, value) = _decode(IoK8sApiRbacV1AggregationRule, value, true) +function _decode(::Type{IoK8sApiRbacV1AggregationRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.AggregationRule"), _openapi_raw, "decoding IoK8sApiRbacV1AggregationRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1AggregationRule") + _openapi_field_clusterroleselectors = haskey(_openapi_object, "clusterRoleSelectors") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelector}}}, _openapi_object["clusterRoleSelectors"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clusterRoleSelectors",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1AggregationRule(; clusterroleselectors = _openapi_field_clusterroleselectors, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1AggregationRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clusterroleselectors isa Absent || (_openapi_output["clusterRoleSelectors"] = _encode(_openapi_value.clusterroleselectors)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.AggregationRule"), _openapi_output, "encoding IoK8sApiRbacV1AggregationRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1AggregationRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.clusterroleselectors isa Absent || push!(_openapi_output, "clusterRoleSelectors" => _openapi_value.clusterroleselectors) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1PolicyRule + apigroups::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + nonresourceurls::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + resourcenames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + resources::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + verbs::Union{Nothing,Vector{String}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1PolicyRule}, value) = _decode(IoK8sApiRbacV1PolicyRule, value, true) +function _decode(::Type{IoK8sApiRbacV1PolicyRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.PolicyRule"), _openapi_raw, "decoding IoK8sApiRbacV1PolicyRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1PolicyRule") + _openapi_field_apigroups = haskey(_openapi_object, "apiGroups") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["apiGroups"], _openapi_validate) : ABSENT + _openapi_field_nonresourceurls = haskey(_openapi_object, "nonResourceURLs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["nonResourceURLs"], _openapi_validate) : ABSENT + _openapi_field_resourcenames = haskey(_openapi_object, "resourceNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["resourceNames"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApiRbacV1PolicyRule"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroups","nonResourceURLs","resourceNames","resources","verbs") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1PolicyRule(; apigroups = _openapi_field_apigroups, nonresourceurls = _openapi_field_nonresourceurls, resourcenames = _openapi_field_resourcenames, resources = _openapi_field_resources, verbs = _openapi_field_verbs, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1PolicyRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroups isa Absent || (_openapi_output["apiGroups"] = _encode(_openapi_value.apigroups)) + _openapi_value.nonresourceurls isa Absent || (_openapi_output["nonResourceURLs"] = _encode(_openapi_value.nonresourceurls)) + _openapi_value.resourcenames isa Absent || (_openapi_output["resourceNames"] = _encode(_openapi_value.resourcenames)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.PolicyRule"), _openapi_output, "encoding IoK8sApiRbacV1PolicyRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1PolicyRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroups isa Absent || push!(_openapi_output, "apiGroups" => _openapi_value.apigroups) + _openapi_value.nonresourceurls isa Absent || push!(_openapi_output, "nonResourceURLs" => _openapi_value.nonresourceurls) + _openapi_value.resourcenames isa Absent || push!(_openapi_output, "resourceNames" => _openapi_value.resourcenames) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1ClusterRole + aggregationrule::Union{Absent,IoK8sApiRbacV1AggregationRule,Nothing} = ABSENT + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + rules::Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1PolicyRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1ClusterRole}, value) = _decode(IoK8sApiRbacV1ClusterRole, value, true) +function _decode(::Type{IoK8sApiRbacV1ClusterRole}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRole"), _openapi_raw, "decoding IoK8sApiRbacV1ClusterRole"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1ClusterRole") + _openapi_field_aggregationrule = haskey(_openapi_object, "aggregationRule") ? _decode(Union{Absent,IoK8sApiRbacV1AggregationRule,Nothing}, _openapi_object["aggregationRule"], _openapi_validate) : ABSENT + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_rules = haskey(_openapi_object, "rules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1PolicyRule}}}, _openapi_object["rules"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("aggregationRule","apiVersion","kind","metadata","rules") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1ClusterRole(; aggregationrule = _openapi_field_aggregationrule, apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, rules = _openapi_field_rules, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1ClusterRole) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.aggregationrule isa Absent || (_openapi_output["aggregationRule"] = _encode(_openapi_value.aggregationrule)) + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.rules isa Absent || (_openapi_output["rules"] = _encode(_openapi_value.rules)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRole"), _openapi_output, "encoding IoK8sApiRbacV1ClusterRole"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1ClusterRole) + _openapi_output = Pair{String,Any}[] + _openapi_value.aggregationrule isa Absent || push!(_openapi_output, "aggregationRule" => _openapi_value.aggregationrule) + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.rules isa Absent || push!(_openapi_output, "rules" => _openapi_value.rules) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1RoleRef + apigroup::String + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1RoleRef}, value) = _decode(IoK8sApiRbacV1RoleRef, value, true) +function _decode(::Type{IoK8sApiRbacV1RoleRef}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleRef"), _openapi_raw, "decoding IoK8sApiRbacV1RoleRef"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1RoleRef") + _openapi_field_apigroup = _decode(String, _required(_openapi_object, "apiGroup", "IoK8sApiRbacV1RoleRef"), _openapi_validate) + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiRbacV1RoleRef"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiRbacV1RoleRef"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1RoleRef(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1RoleRef) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleRef"), _openapi_output, "encoding IoK8sApiRbacV1RoleRef"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1RoleRef) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1Subject + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1Subject}, value) = _decode(IoK8sApiRbacV1Subject, value, true) +function _decode(::Type{IoK8sApiRbacV1Subject}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Subject"), _openapi_raw, "decoding IoK8sApiRbacV1Subject"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1Subject") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiRbacV1Subject"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiRbacV1Subject"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1Subject(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1Subject) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Subject"), _openapi_output, "encoding IoK8sApiRbacV1Subject"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1Subject) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1ClusterRoleBinding + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + roleref::IoK8sApiRbacV1RoleRef + subjects::Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1Subject}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1ClusterRoleBinding}, value) = _decode(IoK8sApiRbacV1ClusterRoleBinding, value, true) +function _decode(::Type{IoK8sApiRbacV1ClusterRoleBinding}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding"), _openapi_raw, "decoding IoK8sApiRbacV1ClusterRoleBinding"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1ClusterRoleBinding") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_roleref = _decode(IoK8sApiRbacV1RoleRef, _required(_openapi_object, "roleRef", "IoK8sApiRbacV1ClusterRoleBinding"), _openapi_validate) + _openapi_field_subjects = haskey(_openapi_object, "subjects") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1Subject}}}, _openapi_object["subjects"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","roleRef","subjects") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1ClusterRoleBinding(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, roleref = _openapi_field_roleref, subjects = _openapi_field_subjects, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1ClusterRoleBinding) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.roleref isa Absent || (_openapi_output["roleRef"] = _encode(_openapi_value.roleref)) + _openapi_value.subjects isa Absent || (_openapi_output["subjects"] = _encode(_openapi_value.subjects)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBinding"), _openapi_output, "encoding IoK8sApiRbacV1ClusterRoleBinding"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1ClusterRoleBinding) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.roleref isa Absent || push!(_openapi_output, "roleRef" => _openapi_value.roleref) + _openapi_value.subjects isa Absent || push!(_openapi_output, "subjects" => _openapi_value.subjects) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1ClusterRoleBindingList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiRbacV1ClusterRoleBinding}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1ClusterRoleBindingList}, value) = _decode(IoK8sApiRbacV1ClusterRoleBindingList, value, true) +function _decode(::Type{IoK8sApiRbacV1ClusterRoleBindingList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList"), _openapi_raw, "decoding IoK8sApiRbacV1ClusterRoleBindingList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1ClusterRoleBindingList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiRbacV1ClusterRoleBinding}}, _required(_openapi_object, "items", "IoK8sApiRbacV1ClusterRoleBindingList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1ClusterRoleBindingList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1ClusterRoleBindingList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleBindingList"), _openapi_output, "encoding IoK8sApiRbacV1ClusterRoleBindingList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1ClusterRoleBindingList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1ClusterRoleList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiRbacV1ClusterRole}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1ClusterRoleList}, value) = _decode(IoK8sApiRbacV1ClusterRoleList, value, true) +function _decode(::Type{IoK8sApiRbacV1ClusterRoleList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList"), _openapi_raw, "decoding IoK8sApiRbacV1ClusterRoleList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1ClusterRoleList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiRbacV1ClusterRole}}, _required(_openapi_object, "items", "IoK8sApiRbacV1ClusterRoleList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1ClusterRoleList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1ClusterRoleList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.ClusterRoleList"), _openapi_output, "encoding IoK8sApiRbacV1ClusterRoleList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1ClusterRoleList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1Role + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + rules::Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1PolicyRule}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1Role}, value) = _decode(IoK8sApiRbacV1Role, value, true) +function _decode(::Type{IoK8sApiRbacV1Role}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Role"), _openapi_raw, "decoding IoK8sApiRbacV1Role"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1Role") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_rules = haskey(_openapi_object, "rules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1PolicyRule}}}, _openapi_object["rules"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","rules") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1Role(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, rules = _openapi_field_rules, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1Role) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.rules isa Absent || (_openapi_output["rules"] = _encode(_openapi_value.rules)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.Role"), _openapi_output, "encoding IoK8sApiRbacV1Role"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1Role) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.rules isa Absent || push!(_openapi_output, "rules" => _openapi_value.rules) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1RoleBinding + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + roleref::IoK8sApiRbacV1RoleRef + subjects::Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1Subject}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1RoleBinding}, value) = _decode(IoK8sApiRbacV1RoleBinding, value, true) +function _decode(::Type{IoK8sApiRbacV1RoleBinding}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBinding"), _openapi_raw, "decoding IoK8sApiRbacV1RoleBinding"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1RoleBinding") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_roleref = _decode(IoK8sApiRbacV1RoleRef, _required(_openapi_object, "roleRef", "IoK8sApiRbacV1RoleBinding"), _openapi_validate) + _openapi_field_subjects = haskey(_openapi_object, "subjects") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiRbacV1Subject}}}, _openapi_object["subjects"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","roleRef","subjects") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1RoleBinding(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, roleref = _openapi_field_roleref, subjects = _openapi_field_subjects, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1RoleBinding) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.roleref isa Absent || (_openapi_output["roleRef"] = _encode(_openapi_value.roleref)) + _openapi_value.subjects isa Absent || (_openapi_output["subjects"] = _encode(_openapi_value.subjects)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBinding"), _openapi_output, "encoding IoK8sApiRbacV1RoleBinding"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1RoleBinding) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.roleref isa Absent || push!(_openapi_output, "roleRef" => _openapi_value.roleref) + _openapi_value.subjects isa Absent || push!(_openapi_output, "subjects" => _openapi_value.subjects) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1RoleBindingList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiRbacV1RoleBinding}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1RoleBindingList}, value) = _decode(IoK8sApiRbacV1RoleBindingList, value, true) +function _decode(::Type{IoK8sApiRbacV1RoleBindingList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBindingList"), _openapi_raw, "decoding IoK8sApiRbacV1RoleBindingList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1RoleBindingList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiRbacV1RoleBinding}}, _required(_openapi_object, "items", "IoK8sApiRbacV1RoleBindingList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1RoleBindingList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1RoleBindingList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleBindingList"), _openapi_output, "encoding IoK8sApiRbacV1RoleBindingList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1RoleBindingList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiRbacV1RoleList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiRbacV1Role}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiRbacV1RoleList}, value) = _decode(IoK8sApiRbacV1RoleList, value, true) +function _decode(::Type{IoK8sApiRbacV1RoleList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleList"), _openapi_raw, "decoding IoK8sApiRbacV1RoleList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiRbacV1RoleList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiRbacV1Role}}, _required(_openapi_object, "items", "IoK8sApiRbacV1RoleList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiRbacV1RoleList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiRbacV1RoleList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.api.rbac.v1.RoleList"), _openapi_output, "encoding IoK8sApiRbacV1RoleList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiRbacV1RoleList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getrbacauthorizationv1apiresources = ( + id = "getRbacAuthorizationV1APIResources", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getrbacauthorizationv1apiresources(...)\n\nget available resources\n\n`GET /apis/rbac.authorization.k8s.io/v1/`" +function getrbacauthorizationv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getrbacauthorizationv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1collectionclusterrolebinding = ( + id = "deleteRbacAuthorizationV1CollectionClusterRoleBinding", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1collectionclusterrolebinding(...)\n\ndelete collection of ClusterRoleBinding\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/clusterrolebindings`" +function deleterbacauthorizationv1collectionclusterrolebinding(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleterbacauthorizationv1collectionclusterrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1clusterrolebinding = ( + id = "listRbacAuthorizationV1ClusterRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1clusterrolebinding(...)\n\nlist or watch objects of kind ClusterRoleBinding\n\n`GET /apis/rbac.authorization.k8s.io/v1/clusterrolebindings`" +function listrbacauthorizationv1clusterrolebinding(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1clusterrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createrbacauthorizationv1clusterrolebinding = ( + id = "createRbacAuthorizationV1ClusterRoleBinding", + method = "POST", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createrbacauthorizationv1clusterrolebinding(...)\n\ncreate a ClusterRoleBinding\n\n`POST /apis/rbac.authorization.k8s.io/v1/clusterrolebindings`" +function createrbacauthorizationv1clusterrolebinding(body::IoK8sApiRbacV1ClusterRoleBinding; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createrbacauthorizationv1clusterrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1clusterrolebinding = ( + id = "deleteRbacAuthorizationV1ClusterRoleBinding", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1clusterrolebinding(...)\n\ndelete a ClusterRoleBinding\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}`" +function deleterbacauthorizationv1clusterrolebinding(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleterbacauthorizationv1clusterrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readrbacauthorizationv1clusterrolebinding = ( + id = "readRbacAuthorizationV1ClusterRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readrbacauthorizationv1clusterrolebinding(...)\n\nread the specified ClusterRoleBinding\n\n`GET /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}`" +function readrbacauthorizationv1clusterrolebinding(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readrbacauthorizationv1clusterrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchrbacauthorizationv1clusterrolebinding = ( + id = "patchRbacAuthorizationV1ClusterRoleBinding", + method = "PATCH", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchrbacauthorizationv1clusterrolebinding(...)\n\npartially update the specified ClusterRoleBinding\n\n`PATCH /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}`" +function patchrbacauthorizationv1clusterrolebinding(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchrbacauthorizationv1clusterrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacerbacauthorizationv1clusterrolebinding = ( + id = "replaceRbacAuthorizationV1ClusterRoleBinding", + method = "PUT", + path = "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterrolebindings~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacerbacauthorizationv1clusterrolebinding(...)\n\nreplace the specified ClusterRoleBinding\n\n`PUT /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}`" +function replacerbacauthorizationv1clusterrolebinding(name::String, body::IoK8sApiRbacV1ClusterRoleBinding; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacerbacauthorizationv1clusterrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1collectionclusterrole = ( + id = "deleteRbacAuthorizationV1CollectionClusterRole", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1collectionclusterrole(...)\n\ndelete collection of ClusterRole\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/clusterroles`" +function deleterbacauthorizationv1collectionclusterrole(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleterbacauthorizationv1collectionclusterrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1clusterrole = ( + id = "listRbacAuthorizationV1ClusterRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1clusterrole(...)\n\nlist or watch objects of kind ClusterRole\n\n`GET /apis/rbac.authorization.k8s.io/v1/clusterroles`" +function listrbacauthorizationv1clusterrole(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1clusterrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createrbacauthorizationv1clusterrole = ( + id = "createRbacAuthorizationV1ClusterRole", + method = "POST", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createrbacauthorizationv1clusterrole(...)\n\ncreate a ClusterRole\n\n`POST /apis/rbac.authorization.k8s.io/v1/clusterroles`" +function createrbacauthorizationv1clusterrole(body::IoK8sApiRbacV1ClusterRole; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createrbacauthorizationv1clusterrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1clusterrole = ( + id = "deleteRbacAuthorizationV1ClusterRole", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1clusterrole(...)\n\ndelete a ClusterRole\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/clusterroles/{name}`" +function deleterbacauthorizationv1clusterrole(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleterbacauthorizationv1clusterrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readrbacauthorizationv1clusterrole = ( + id = "readRbacAuthorizationV1ClusterRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readrbacauthorizationv1clusterrole(...)\n\nread the specified ClusterRole\n\n`GET /apis/rbac.authorization.k8s.io/v1/clusterroles/{name}`" +function readrbacauthorizationv1clusterrole(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readrbacauthorizationv1clusterrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchrbacauthorizationv1clusterrole = ( + id = "patchRbacAuthorizationV1ClusterRole", + method = "PATCH", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchrbacauthorizationv1clusterrole(...)\n\npartially update the specified ClusterRole\n\n`PATCH /apis/rbac.authorization.k8s.io/v1/clusterroles/{name}`" +function patchrbacauthorizationv1clusterrole(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchrbacauthorizationv1clusterrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacerbacauthorizationv1clusterrole = ( + id = "replaceRbacAuthorizationV1ClusterRole", + method = "PUT", + path = "/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1ClusterRole, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1clusterroles~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacerbacauthorizationv1clusterrole(...)\n\nreplace the specified ClusterRole\n\n`PUT /apis/rbac.authorization.k8s.io/v1/clusterroles/{name}`" +function replacerbacauthorizationv1clusterrole(name::String, body::IoK8sApiRbacV1ClusterRole; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacerbacauthorizationv1clusterrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1collectionnamespacedrolebinding = ( + id = "deleteRbacAuthorizationV1CollectionNamespacedRoleBinding", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1collectionnamespacedrolebinding(...)\n\ndelete collection of RoleBinding\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings`" +function deleterbacauthorizationv1collectionnamespacedrolebinding(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleterbacauthorizationv1collectionnamespacedrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1namespacedrolebinding = ( + id = "listRbacAuthorizationV1NamespacedRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1namespacedrolebinding(...)\n\nlist or watch objects of kind RoleBinding\n\n`GET /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings`" +function listrbacauthorizationv1namespacedrolebinding(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1namespacedrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createrbacauthorizationv1namespacedrolebinding = ( + id = "createRbacAuthorizationV1NamespacedRoleBinding", + method = "POST", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createrbacauthorizationv1namespacedrolebinding(...)\n\ncreate a RoleBinding\n\n`POST /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings`" +function createrbacauthorizationv1namespacedrolebinding(namespace::String, body::IoK8sApiRbacV1RoleBinding; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createrbacauthorizationv1namespacedrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1namespacedrolebinding = ( + id = "deleteRbacAuthorizationV1NamespacedRoleBinding", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1namespacedrolebinding(...)\n\ndelete a RoleBinding\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}`" +function deleterbacauthorizationv1namespacedrolebinding(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleterbacauthorizationv1namespacedrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readrbacauthorizationv1namespacedrolebinding = ( + id = "readRbacAuthorizationV1NamespacedRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readrbacauthorizationv1namespacedrolebinding(...)\n\nread the specified RoleBinding\n\n`GET /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}`" +function readrbacauthorizationv1namespacedrolebinding(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readrbacauthorizationv1namespacedrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchrbacauthorizationv1namespacedrolebinding = ( + id = "patchRbacAuthorizationV1NamespacedRoleBinding", + method = "PATCH", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchrbacauthorizationv1namespacedrolebinding(...)\n\npartially update the specified RoleBinding\n\n`PATCH /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}`" +function patchrbacauthorizationv1namespacedrolebinding(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchrbacauthorizationv1namespacedrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacerbacauthorizationv1namespacedrolebinding = ( + id = "replaceRbacAuthorizationV1NamespacedRoleBinding", + method = "PUT", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBinding, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1rolebindings~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacerbacauthorizationv1namespacedrolebinding(...)\n\nreplace the specified RoleBinding\n\n`PUT /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}`" +function replacerbacauthorizationv1namespacedrolebinding(namespace::String, name::String, body::IoK8sApiRbacV1RoleBinding; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacerbacauthorizationv1namespacedrolebinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1collectionnamespacedrole = ( + id = "deleteRbacAuthorizationV1CollectionNamespacedRole", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1collectionnamespacedrole(...)\n\ndelete collection of Role\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles`" +function deleterbacauthorizationv1collectionnamespacedrole(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleterbacauthorizationv1collectionnamespacedrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1namespacedrole = ( + id = "listRbacAuthorizationV1NamespacedRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1namespacedrole(...)\n\nlist or watch objects of kind Role\n\n`GET /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles`" +function listrbacauthorizationv1namespacedrole(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1namespacedrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createrbacauthorizationv1namespacedrole = ( + id = "createRbacAuthorizationV1NamespacedRole", + method = "POST", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createrbacauthorizationv1namespacedrole(...)\n\ncreate a Role\n\n`POST /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles`" +function createrbacauthorizationv1namespacedrole(namespace::String, body::IoK8sApiRbacV1Role; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createrbacauthorizationv1namespacedrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleterbacauthorizationv1namespacedrole = ( + id = "deleteRbacAuthorizationV1NamespacedRole", + method = "DELETE", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleterbacauthorizationv1namespacedrole(...)\n\ndelete a Role\n\n`DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}`" +function deleterbacauthorizationv1namespacedrole(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleterbacauthorizationv1namespacedrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readrbacauthorizationv1namespacedrole = ( + id = "readRbacAuthorizationV1NamespacedRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readrbacauthorizationv1namespacedrole(...)\n\nread the specified Role\n\n`GET /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}`" +function readrbacauthorizationv1namespacedrole(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readrbacauthorizationv1namespacedrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchrbacauthorizationv1namespacedrole = ( + id = "patchRbacAuthorizationV1NamespacedRole", + method = "PATCH", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchrbacauthorizationv1namespacedrole(...)\n\npartially update the specified Role\n\n`PATCH /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}`" +function patchrbacauthorizationv1namespacedrole(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchrbacauthorizationv1namespacedrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacerbacauthorizationv1namespacedrole = ( + id = "replaceRbacAuthorizationV1NamespacedRole", + method = "PUT", + path = "/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiRbacV1Role, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1namespaces~1{namespace}~1roles~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacerbacauthorizationv1namespacedrole(...)\n\nreplace the specified Role\n\n`PUT /apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}`" +function replacerbacauthorizationv1namespacedrole(namespace::String, name::String, body::IoK8sApiRbacV1Role; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacerbacauthorizationv1namespacedrole, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1rolebindingforallnamespaces = ( + id = "listRbacAuthorizationV1RoleBindingForAllNamespaces", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/rolebindings", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleBindingList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1rolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1rolebindingforallnamespaces(...)\n\nlist or watch objects of kind RoleBinding\n\n`GET /apis/rbac.authorization.k8s.io/v1/rolebindings`" +function listrbacauthorizationv1rolebindingforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1rolebindingforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listrbacauthorizationv1roleforallnamespaces = ( + id = "listRbacAuthorizationV1RoleForAllNamespaces", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/roles", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiRbacV1RoleList, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1roles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listrbacauthorizationv1roleforallnamespaces(...)\n\nlist or watch objects of kind Role\n\n`GET /apis/rbac.authorization.k8s.io/v1/roles`" +function listrbacauthorizationv1roleforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listrbacauthorizationv1roleforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1clusterrolebindinglist = ( + id = "watchRbacAuthorizationV1ClusterRoleBindingList", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1clusterrolebindinglist(...)\n\nwatch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings`" +function watchrbacauthorizationv1clusterrolebindinglist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1clusterrolebindinglist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1clusterrolebinding = ( + id = "watchRbacAuthorizationV1ClusterRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterrolebindings~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1clusterrolebinding(...)\n\nwatch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/{name}`" +function watchrbacauthorizationv1clusterrolebinding(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1clusterrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1clusterrolelist = ( + id = "watchRbacAuthorizationV1ClusterRoleList", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1clusterrolelist(...)\n\nwatch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/clusterroles`" +function watchrbacauthorizationv1clusterrolelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1clusterrolelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1clusterrole = ( + id = "watchRbacAuthorizationV1ClusterRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1clusterroles~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1clusterrole(...)\n\nwatch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/clusterroles/{name}`" +function watchrbacauthorizationv1clusterrole(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1clusterrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1namespacedrolebindinglist = ( + id = "watchRbacAuthorizationV1NamespacedRoleBindingList", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1namespacedrolebindinglist(...)\n\nwatch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings`" +function watchrbacauthorizationv1namespacedrolebindinglist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1namespacedrolebindinglist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1namespacedrolebinding = ( + id = "watchRbacAuthorizationV1NamespacedRoleBinding", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1rolebindings~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1namespacedrolebinding(...)\n\nwatch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/rolebindings/{name}`" +function watchrbacauthorizationv1namespacedrolebinding(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1namespacedrolebinding, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1namespacedrolelist = ( + id = "watchRbacAuthorizationV1NamespacedRoleList", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1namespacedrolelist(...)\n\nwatch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles`" +function watchrbacauthorizationv1namespacedrolelist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1namespacedrolelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1namespacedrole = ( + id = "watchRbacAuthorizationV1NamespacedRole", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1namespaces~1{namespace}~1roles~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1namespacedrole(...)\n\nwatch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/{namespace}/roles/{name}`" +function watchrbacauthorizationv1namespacedrole(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1namespacedrole, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1rolebindinglistforallnamespaces = ( + id = "watchRbacAuthorizationV1RoleBindingListForAllNamespaces", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/rolebindings", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1rolebindings/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1rolebindinglistforallnamespaces(...)\n\nwatch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/rolebindings`" +function watchrbacauthorizationv1rolebindinglistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1rolebindinglistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchrbacauthorizationv1rolelistforallnamespaces = ( + id = "watchRbacAuthorizationV1RoleListForAllNamespaces", + method = "GET", + path = "/apis/rbac.authorization.k8s.io/v1/watch/roles", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-8d6c59100318f75600b3.json", pointer = "/paths/~1apis~1rbac.authorization.k8s.io~1v1~1watch~1roles/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchrbacauthorizationv1rolelistforallnamespaces(...)\n\nwatch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/rbac.authorization.k8s.io/v1/watch/roles`" +function watchrbacauthorizationv1rolelistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchrbacauthorizationv1rolelistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sRbacAuthorizationK8sIoV1 diff --git a/src/ApiImpl/generated/K8sSchedulingK8sIoV1.jl b/src/ApiImpl/generated/K8sSchedulingK8sIoV1.jl new file mode 100644 index 00000000..6183ee58 --- /dev/null +++ b/src/ApiImpl/generated/K8sSchedulingK8sIoV1.jl @@ -0,0 +1,1440 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sSchedulingK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", retrieval = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.scheduling.v1.PriorityClass\":{\"description\":\"PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"description\":{\"description\":\"description is an arbitrary string that usually provides guidelines on when this priority class should be used.\",\"type\":\"string\"},\"globalDefault\":{\"description\":\"globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"preemptionPolicy\":{\"description\":\"preemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.\",\"type\":\"string\"},\"value\":{\"default\":0,\"description\":\"value represents the integer value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"value\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}]},\"io.k8s.api.scheduling.v1.PriorityClassList\":{\"description\":\"PriorityClassList is a collection of priority classes.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of PriorityClasses\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClassList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/scheduling.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getSchedulingV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"]}},\"/apis/scheduling.k8s.io/v1/priorityclasses\":{\"delete\":{\"description\":\"delete collection of PriorityClass\",\"operationId\":\"deleteSchedulingV1CollectionPriorityClass\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind PriorityClass\",\"operationId\":\"listSchedulingV1PriorityClass\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a PriorityClass\",\"operationId\":\"createSchedulingV1PriorityClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}}},\"/apis/scheduling.k8s.io/v1/priorityclasses/{name}\":{\"delete\":{\"description\":\"delete a PriorityClass\",\"operationId\":\"deleteSchedulingV1PriorityClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified PriorityClass\",\"operationId\":\"readSchedulingV1PriorityClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the PriorityClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified PriorityClass\",\"operationId\":\"patchSchedulingV1PriorityClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified PriorityClass\",\"operationId\":\"replaceSchedulingV1PriorityClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.api.scheduling.v1.PriorityClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}}},\"/apis/scheduling.k8s.io/v1/watch/priorityclasses\":{\"get\":{\"description\":\"watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchSchedulingV1PriorityClassList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchSchedulingV1PriorityClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"scheduling_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"scheduling.k8s.io\",\"kind\":\"PriorityClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the PriorityClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClass", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiSchedulingV1PriorityClass + apiversion::Union{Absent,Nothing,String} = ABSENT + description::Union{Absent,Nothing,String} = ABSENT + globaldefault::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + preemptionpolicy::Union{Absent,Nothing,String} = ABSENT + value::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiSchedulingV1PriorityClass}, value) = _decode(IoK8sApiSchedulingV1PriorityClass, value, true) +function _decode(::Type{IoK8sApiSchedulingV1PriorityClass}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClass"), _openapi_raw, "decoding IoK8sApiSchedulingV1PriorityClass"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiSchedulingV1PriorityClass") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_description = haskey(_openapi_object, "description") ? _decode(Union{Absent,Nothing,String}, _openapi_object["description"], _openapi_validate) : ABSENT + _openapi_field_globaldefault = haskey(_openapi_object, "globalDefault") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["globalDefault"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_preemptionpolicy = haskey(_openapi_object, "preemptionPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["preemptionPolicy"], _openapi_validate) : ABSENT + _openapi_field_value = _decode(Int32, _required(_openapi_object, "value", "IoK8sApiSchedulingV1PriorityClass"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","description","globalDefault","kind","metadata","preemptionPolicy","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiSchedulingV1PriorityClass(; apiversion = _openapi_field_apiversion, description = _openapi_field_description, globaldefault = _openapi_field_globaldefault, kind = _openapi_field_kind, metadata = _openapi_field_metadata, preemptionpolicy = _openapi_field_preemptionpolicy, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiSchedulingV1PriorityClass) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.description isa Absent || (_openapi_output["description"] = _encode(_openapi_value.description)) + _openapi_value.globaldefault isa Absent || (_openapi_output["globalDefault"] = _encode(_openapi_value.globaldefault)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.preemptionpolicy isa Absent || (_openapi_output["preemptionPolicy"] = _encode(_openapi_value.preemptionpolicy)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClass"), _openapi_output, "encoding IoK8sApiSchedulingV1PriorityClass"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiSchedulingV1PriorityClass) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.description isa Absent || push!(_openapi_output, "description" => _openapi_value.description) + _openapi_value.globaldefault isa Absent || push!(_openapi_output, "globalDefault" => _openapi_value.globaldefault) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.preemptionpolicy isa Absent || push!(_openapi_output, "preemptionPolicy" => _openapi_value.preemptionpolicy) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiSchedulingV1PriorityClassList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiSchedulingV1PriorityClass}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiSchedulingV1PriorityClassList}, value) = _decode(IoK8sApiSchedulingV1PriorityClassList, value, true) +function _decode(::Type{IoK8sApiSchedulingV1PriorityClassList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList"), _openapi_raw, "decoding IoK8sApiSchedulingV1PriorityClassList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiSchedulingV1PriorityClassList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiSchedulingV1PriorityClass}}, _required(_openapi_object, "items", "IoK8sApiSchedulingV1PriorityClassList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiSchedulingV1PriorityClassList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiSchedulingV1PriorityClassList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.api.scheduling.v1.PriorityClassList"), _openapi_output, "encoding IoK8sApiSchedulingV1PriorityClassList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiSchedulingV1PriorityClassList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getschedulingv1apiresources = ( + id = "getSchedulingV1APIResources", + method = "GET", + path = "/apis/scheduling.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getschedulingv1apiresources(...)\n\nget available resources\n\n`GET /apis/scheduling.k8s.io/v1/`" +function getschedulingv1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getschedulingv1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteschedulingv1collectionpriorityclass = ( + id = "deleteSchedulingV1CollectionPriorityClass", + method = "DELETE", + path = "/apis/scheduling.k8s.io/v1/priorityclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteschedulingv1collectionpriorityclass(...)\n\ndelete collection of PriorityClass\n\n`DELETE /apis/scheduling.k8s.io/v1/priorityclasses`" +function deleteschedulingv1collectionpriorityclass(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deleteschedulingv1collectionpriorityclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listschedulingv1priorityclass = ( + id = "listSchedulingV1PriorityClass", + method = "GET", + path = "/apis/scheduling.k8s.io/v1/priorityclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClassList, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listschedulingv1priorityclass(...)\n\nlist or watch objects of kind PriorityClass\n\n`GET /apis/scheduling.k8s.io/v1/priorityclasses`" +function listschedulingv1priorityclass(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listschedulingv1priorityclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createschedulingv1priorityclass = ( + id = "createSchedulingV1PriorityClass", + method = "POST", + path = "/apis/scheduling.k8s.io/v1/priorityclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createschedulingv1priorityclass(...)\n\ncreate a PriorityClass\n\n`POST /apis/scheduling.k8s.io/v1/priorityclasses`" +function createschedulingv1priorityclass(body::IoK8sApiSchedulingV1PriorityClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createschedulingv1priorityclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deleteschedulingv1priorityclass = ( + id = "deleteSchedulingV1PriorityClass", + method = "DELETE", + path = "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deleteschedulingv1priorityclass(...)\n\ndelete a PriorityClass\n\n`DELETE /apis/scheduling.k8s.io/v1/priorityclasses/{name}`" +function deleteschedulingv1priorityclass(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deleteschedulingv1priorityclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readschedulingv1priorityclass = ( + id = "readSchedulingV1PriorityClass", + method = "GET", + path = "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readschedulingv1priorityclass(...)\n\nread the specified PriorityClass\n\n`GET /apis/scheduling.k8s.io/v1/priorityclasses/{name}`" +function readschedulingv1priorityclass(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readschedulingv1priorityclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchschedulingv1priorityclass = ( + id = "patchSchedulingV1PriorityClass", + method = "PATCH", + path = "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchschedulingv1priorityclass(...)\n\npartially update the specified PriorityClass\n\n`PATCH /apis/scheduling.k8s.io/v1/priorityclasses/{name}`" +function patchschedulingv1priorityclass(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchschedulingv1priorityclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replaceschedulingv1priorityclass = ( + id = "replaceSchedulingV1PriorityClass", + method = "PUT", + path = "/apis/scheduling.k8s.io/v1/priorityclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiSchedulingV1PriorityClass, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1priorityclasses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replaceschedulingv1priorityclass(...)\n\nreplace the specified PriorityClass\n\n`PUT /apis/scheduling.k8s.io/v1/priorityclasses/{name}`" +function replaceschedulingv1priorityclass(name::String, body::IoK8sApiSchedulingV1PriorityClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replaceschedulingv1priorityclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchschedulingv1priorityclasslist = ( + id = "watchSchedulingV1PriorityClassList", + method = "GET", + path = "/apis/scheduling.k8s.io/v1/watch/priorityclasses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchschedulingv1priorityclasslist(...)\n\nwatch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/scheduling.k8s.io/v1/watch/priorityclasses`" +function watchschedulingv1priorityclasslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchschedulingv1priorityclasslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchschedulingv1priorityclass = ( + id = "watchSchedulingV1PriorityClass", + method = "GET", + path = "/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-d33b9a01bbf1cc43988e.json", pointer = "/paths/~1apis~1scheduling.k8s.io~1v1~1watch~1priorityclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchschedulingv1priorityclass(...)\n\nwatch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}`" +function watchschedulingv1priorityclass(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchschedulingv1priorityclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sSchedulingK8sIoV1 diff --git a/src/ApiImpl/generated/K8sStorageK8sIoV1.jl b/src/ApiImpl/generated/K8sStorageK8sIoV1.jl new file mode 100644 index 00000000..b1d95490 --- /dev/null +++ b/src/ApiImpl/generated/K8sStorageK8sIoV1.jl @@ -0,0 +1,6411 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sStorageK8sIoV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", retrieval = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in AWS.\\n\\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty).\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureDiskVolumeSource\":{\"description\":\"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.\",\"properties\":{\"cachingMode\":{\"default\":\"ReadWrite\",\"description\":\"cachingMode is the Host Caching mode: None, Read Only, Read Write.\",\"type\":\"string\"},\"diskName\":{\"default\":\"\",\"description\":\"diskName is the Name of the data disk in the blob storage\",\"type\":\"string\"},\"diskURI\":{\"default\":\"\",\"description\":\"diskURI is the URI of data disk in the blob storage\",\"type\":\"string\"},\"fsType\":{\"default\":\"ext4\",\"description\":\"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"kind\":{\"default\":\"Shared\",\"description\":\"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared\",\"type\":\"string\"},\"readOnly\":{\"default\":false,\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"}},\"required\":[\"diskName\",\"diskURI\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureFilePersistentVolumeSource\":{\"description\":\"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.\",\"properties\":{\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretName\":{\"default\":\"\",\"description\":\"secretName is the name of secret that contains Azure Storage Account Name and Key\",\"type\":\"string\"},\"secretNamespace\":{\"description\":\"secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod\",\"type\":\"string\"},\"shareName\":{\"default\":\"\",\"description\":\"shareName is the azure Share Name\",\"type\":\"string\"}},\"required\":[\"secretName\",\"shareName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CSIPersistentVolumeSource\":{\"description\":\"Represents storage that is managed by an external CSI volume driver\",\"properties\":{\"controllerExpandSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"controllerPublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume. Required.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\".\",\"type\":\"string\"},\"nodeExpandSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"nodePublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"nodeStageSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"readOnly\":{\"description\":\"readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).\",\"type\":\"boolean\"},\"volumeAttributes\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"volumeAttributes of the volume to publish.\",\"type\":\"object\"},\"volumeHandle\":{\"default\":\"\",\"description\":\"volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.\",\"type\":\"string\"}},\"required\":[\"driver\",\"volumeHandle\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CephFSPersistentVolumeSource\":{\"description\":\"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"monitors\":{\"description\":\"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretFile\":{\"description\":\"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"user\":{\"description\":\"user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CinderPersistentVolumeSource\":{\"description\":\"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FCVolumeSource\":{\"description\":\"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"lun\":{\"description\":\"lun is Optional: FC target lun number\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"targetWWNs\":{\"description\":\"targetWWNs is Optional: FC target worldwide names (WWNs)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"wwids\":{\"description\":\"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FlexPersistentVolumeSource\":{\"description\":\"FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default filesystem depends on FlexVolume script.\",\"type\":\"string\"},\"options\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"options is Optional: this field holds extra command options if any.\",\"type\":\"object\"},\"readOnly\":{\"description\":\"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FlockerVolumeSource\":{\"description\":\"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"datasetName\":{\"description\":\"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated\",\"type\":\"string\"},\"datasetUUID\":{\"description\":\"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in Google Compute Engine.\\n\\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"format\":\"int32\",\"type\":\"integer\"},\"pdName\":{\"default\":\"\",\"description\":\"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"boolean\"}},\"required\":[\"pdName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GlusterfsPersistentVolumeSource\":{\"description\":\"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"endpoints\":{\"default\":\"\",\"description\":\"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"endpointsNamespace\":{\"description\":\"endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"boolean\"}},\"required\":[\"endpoints\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostPathVolumeSource\":{\"description\":\"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"},\"type\":{\"description\":\"type for HostPath Volume Defaults to \\\"\\\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ISCSIPersistentVolumeSource\":{\"description\":\"ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.\",\"properties\":{\"chapAuthDiscovery\":{\"description\":\"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication\",\"type\":\"boolean\"},\"chapAuthSession\":{\"description\":\"chapAuthSession defines whether support iSCSI Session CHAP authentication\",\"type\":\"boolean\"},\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi\",\"type\":\"string\"},\"initiatorName\":{\"description\":\"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.\",\"type\":\"string\"},\"iqn\":{\"default\":\"\",\"description\":\"iqn is Target iSCSI Qualified Name.\",\"type\":\"string\"},\"iscsiInterface\":{\"default\":\"default\",\"description\":\"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).\",\"type\":\"string\"},\"lun\":{\"default\":0,\"description\":\"lun is iSCSI Target Lun number.\",\"format\":\"int32\",\"type\":\"integer\"},\"portals\":{\"description\":\"portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"targetPortal\":{\"default\":\"\",\"description\":\"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"type\":\"string\"}},\"required\":[\"targetPortal\",\"iqn\",\"lun\"],\"type\":\"object\"},\"io.k8s.api.core.v1.LocalVolumeSource\":{\"description\":\"Local represents directly-attached storage with node affinity\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default value is to auto-select a filesystem if unspecified.\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NFSVolumeSource\":{\"description\":\"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"boolean\"},\"server\":{\"default\":\"\",\"description\":\"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"}},\"required\":[\"server\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelector\":{\"description\":\"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.\",\"properties\":{\"nodeSelectorTerms\":{\"description\":\"Required. A list of node selector terms. The terms are ORed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"nodeSelectorTerms\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NodeSelectorRequirement\":{\"description\":\"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelectorTerm\":{\"description\":\"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\",\"properties\":{\"matchExpressions\":{\"description\":\"A list of node selector requirements by node's labels.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchFields\":{\"description\":\"A list of node selector requirements by node's fields.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ObjectReference\":{\"description\":\"ObjectReference contains enough information to let you inspect or modify the referred object.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"fieldPath\":{\"description\":\"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \\\"spec.containers{name}\\\" (where \\\"name\\\" refers to the name of the container that triggered the event) or if no container name is specified \\\"spec.containers[2]\\\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.PersistentVolumeSpec\":{\"description\":\"PersistentVolumeSpec is the specification of a persistent volume.\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"awsElasticBlockStore\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\"},\"azureDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource\"},\"azureFile\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource\"},\"capacity\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity\",\"type\":\"object\"},\"cephfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource\"},\"cinder\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource\"},\"claimRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"csi\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource\"},\"fc\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.FCVolumeSource\"},\"flexVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource\"},\"flocker\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource\"},\"gcePersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\"},\"glusterfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource\"},\"hostPath\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource\"},\"iscsi\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource\"},\"local\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource\"},\"mountOptions\":{\"description\":\"mountOptions is the list of mount options, e.g. [\\\"ro\\\", \\\"soft\\\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"nfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource\"},\"nodeAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity\"},\"persistentVolumeReclaimPolicy\":{\"description\":\"persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming\",\"type\":\"string\"},\"photonPersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\"},\"portworxVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource\"},\"quobyte\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource\"},\"rbd\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource\"},\"scaleIO\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource\"},\"storageClassName\":{\"description\":\"storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.\",\"type\":\"string\"},\"storageos\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource\"},\"volumeAttributesClassName\":{\"description\":\"Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.\",\"type\":\"string\"},\"volumeMode\":{\"description\":\"volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.\",\"type\":\"string\"},\"vsphereVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\":{\"description\":\"Represents a Photon Controller persistent disk resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"pdID\":{\"default\":\"\",\"description\":\"pdID is the ID that identifies Photon Controller persistent disk\",\"type\":\"string\"}},\"required\":[\"pdID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PortworxVolumeSource\":{\"description\":\"PortworxVolumeSource represents a Portworx volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID uniquely identifies a Portworx volume\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.QuobyteVolumeSource\":{\"description\":\"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"group\":{\"description\":\"group to map volume access to Default is no group\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.\",\"type\":\"boolean\"},\"registry\":{\"default\":\"\",\"description\":\"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes\",\"type\":\"string\"},\"tenant\":{\"description\":\"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin\",\"type\":\"string\"},\"user\":{\"description\":\"user to map volume access to Defaults to serivceaccount user\",\"type\":\"string\"},\"volume\":{\"default\":\"\",\"description\":\"volume is a string that references an already created Quobyte volume by name.\",\"type\":\"string\"}},\"required\":[\"registry\",\"volume\"],\"type\":\"object\"},\"io.k8s.api.core.v1.RBDPersistentVolumeSource\":{\"description\":\"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"keyring\":{\"default\":\"/etc/ceph/keyring\",\"description\":\"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"monitors\":{\"description\":\"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pool\":{\"default\":\"rbd\",\"description\":\"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"user\":{\"default\":\"admin\",\"description\":\"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\",\"image\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ScaleIOPersistentVolumeSource\":{\"description\":\"ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume\",\"properties\":{\"fsType\":{\"default\":\"xfs\",\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Default is \\\"xfs\\\"\",\"type\":\"string\"},\"gateway\":{\"default\":\"\",\"description\":\"gateway is the host address of the ScaleIO API Gateway.\",\"type\":\"string\"},\"protectionDomain\":{\"description\":\"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"sslEnabled\":{\"description\":\"sslEnabled is the flag to enable/disable SSL communication with Gateway, default false\",\"type\":\"boolean\"},\"storageMode\":{\"default\":\"ThinProvisioned\",\"description\":\"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.\",\"type\":\"string\"},\"storagePool\":{\"description\":\"storagePool is the ScaleIO Storage Pool associated with the protection domain.\",\"type\":\"string\"},\"system\":{\"default\":\"\",\"description\":\"system is the name of the storage system as configured in ScaleIO.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.\",\"type\":\"string\"}},\"required\":[\"gateway\",\"system\",\"secretRef\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SecretReference\":{\"description\":\"SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace\",\"properties\":{\"name\":{\"description\":\"name is unique within a namespace to reference a secret resource.\",\"type\":\"string\"},\"namespace\":{\"description\":\"namespace defines the space within which the secret name must be unique.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.StorageOSPersistentVolumeSource\":{\"description\":\"Represents a StorageOS persistent volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"volumeName\":{\"description\":\"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.\",\"type\":\"string\"},\"volumeNamespace\":{\"description\":\"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \\\"default\\\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.TopologySelectorLabelRequirement\":{\"description\":\"A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The label key that the selector applies to.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. One value must match the label to be selected. Each entry in Values is ORed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"values\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TopologySelectorTerm\":{\"description\":\"A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future.\",\"properties\":{\"matchLabelExpressions\":{\"description\":\"A list of topology selector requirements by labels.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.VolumeNodeAffinity\":{\"description\":\"VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.\",\"properties\":{\"required\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.NodeSelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\":{\"description\":\"Represents a vSphere volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"storagePolicyID\":{\"description\":\"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.\",\"type\":\"string\"},\"storagePolicyName\":{\"description\":\"storagePolicyName is the storage Policy Based Management (SPBM) profile name.\",\"type\":\"string\"},\"volumePath\":{\"default\":\"\",\"description\":\"volumePath is the path that identifies vSphere volume vmdk\",\"type\":\"string\"}},\"required\":[\"volumePath\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.CSIDriver\":{\"description\":\"CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.CSIDriverList\":{\"description\":\"CSIDriverList is a collection of CSIDriver objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of CSIDriver\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriverList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.CSIDriverSpec\":{\"description\":\"CSIDriverSpec is the specification of a CSIDriver.\",\"properties\":{\"attachRequired\":{\"description\":\"attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called.\\n\\nThis field is immutable.\",\"type\":\"boolean\"},\"fsGroupPolicy\":{\"description\":\"fsGroupPolicy defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details.\\n\\nThis field was immutable in Kubernetes < 1.29 and now is mutable.\\n\\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.\",\"type\":\"string\"},\"nodeAllocatableUpdatePeriodSeconds\":{\"description\":\"nodeAllocatableUpdatePeriodSeconds specifies the interval between periodic updates of the CSINode allocatable capacity for this driver. When set, both periodic updates and updates triggered by capacity-related failures are enabled. If not set, no updates occur (neither periodic nor upon detecting capacity-related failures), and the allocatable.count remains static. The minimum allowed value for this field is 10 seconds.\\n\\nThis is a beta feature and requires the MutableCSINodeAllocatableCount feature gate to be enabled.\\n\\nThis field is mutable.\",\"format\":\"int64\",\"type\":\"integer\"},\"podInfoOnMount\":{\"description\":\"podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations, if set to true. If set to false, pod information will not be passed on mount. Default is false.\\n\\nThe CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext.\\n\\nThe following VolumeContext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \\\"csi.storage.k8s.io/pod.name\\\": pod.Name \\\"csi.storage.k8s.io/pod.namespace\\\": pod.Namespace \\\"csi.storage.k8s.io/pod.uid\\\": string(pod.UID) \\\"csi.storage.k8s.io/ephemeral\\\": \\\"true\\\" if the volume is an ephemeral inline volume\\n defined by a CSIVolumeSource, otherwise \\\"false\\\"\\n\\n\\\"csi.storage.k8s.io/ephemeral\\\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \\\"Persistent\\\" and \\\"Ephemeral\\\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver.\\n\\nThis field was immutable in Kubernetes < 1.29 and now is mutable.\",\"type\":\"boolean\"},\"requiresRepublish\":{\"description\":\"requiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false.\\n\\nNote: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container.\",\"type\":\"boolean\"},\"seLinuxMount\":{\"description\":\"seLinuxMount specifies if the CSI driver supports \\\"-o context\\\" mount option.\\n\\nWhen \\\"true\\\", the CSI driver must ensure that all volumes provided by this CSI driver can be mounted separately with different `-o context` options. This is typical for storage backends that provide volumes as filesystems on block devices or as independent shared volumes. Kubernetes will call NodeStage / NodePublish with \\\"-o context=xyz\\\" mount option when mounting a ReadWriteOncePod volume used in Pod that has explicitly set SELinux context. In the future, it may be expanded to other volume AccessModes. In any case, Kubernetes will ensure that the volume is mounted only with a single SELinux context.\\n\\nWhen \\\"false\\\", Kubernetes won't pass any special SELinux mount options to the driver. This is typical for volumes that represent subdirectories of a bigger shared filesystem.\\n\\nDefault is \\\"false\\\".\",\"type\":\"boolean\"},\"serviceAccountTokenInSecrets\":{\"description\":\"serviceAccountTokenInSecrets is an opt-in for CSI drivers to indicate that service account tokens should be passed via the Secrets field in NodePublishVolumeRequest instead of the VolumeContext field. The CSI specification provides a dedicated Secrets field for sensitive information like tokens, which is the appropriate mechanism for handling credentials. This addresses security concerns where sensitive tokens were being logged as part of volume context.\\n\\nWhen \\\"true\\\", kubelet will pass the tokens only in the Secrets field with the key \\\"csi.storage.k8s.io/serviceAccount.tokens\\\". The CSI driver must be updated to read tokens from the Secrets field instead of VolumeContext.\\n\\nWhen \\\"false\\\" or not set, kubelet will pass the tokens in VolumeContext with the key \\\"csi.storage.k8s.io/serviceAccount.tokens\\\" (existing behavior). This maintains backward compatibility with existing CSI drivers.\\n\\nThis field can only be set when TokenRequests is configured. The API server will reject CSIDriver specs that set this field without TokenRequests.\\n\\nDefault behavior if unset is to pass tokens in the VolumeContext field.\",\"type\":\"boolean\"},\"storageCapacity\":{\"description\":\"storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information, if set to true.\\n\\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\\n\\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\\n\\nThis field was immutable in Kubernetes <= 1.22 and now is mutable.\",\"type\":\"boolean\"},\"tokenRequests\":{\"description\":\"tokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: \\\"csi.storage.k8s.io/serviceAccount.tokens\\\": {\\n \\\"\\\": {\\n \\\"token\\\": ,\\n \\\"expirationTimestamp\\\": ,\\n },\\n ...\\n}\\n\\nNote: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.TokenRequest\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"volumeLifecycleModes\":{\"description\":\"volumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \\\"Persistent\\\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism.\\n\\nThe other mode is \\\"Ephemeral\\\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume.\\n\\nFor more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future.\\n\\nThis field is beta. This field is immutable.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.storage.v1.CSINode\":{\"description\":\"CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeSpec\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.CSINodeDriver\":{\"description\":\"CSINodeDriver holds information about the specification of one CSI driver installed on a node\",\"properties\":{\"allocatable\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources\"},\"name\":{\"default\":\"\",\"description\":\"name represents the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver.\",\"type\":\"string\"},\"nodeID\":{\"default\":\"\",\"description\":\"nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as \\\"node1\\\", but the storage system may refer to the same node as \\\"nodeA\\\". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. \\\"nodeA\\\" instead of \\\"node1\\\". This field is required.\",\"type\":\"string\"},\"topologyKeys\":{\"description\":\"topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. \\\"company.com/zone\\\", \\\"company.com/region\\\"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"name\",\"nodeID\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.CSINodeList\":{\"description\":\"CSINodeList is a collection of CSINode objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of CSINode\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSINodeList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.CSINodeSpec\":{\"description\":\"CSINodeSpec holds information about the specification of all CSI drivers installed on a node\",\"properties\":{\"drivers\":{\"description\":\"drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeDriver\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"required\":[\"drivers\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.CSIStorageCapacity\":{\"description\":\"CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes.\\n\\nFor example this can express things like: - StorageClass \\\"standard\\\" has \\\"1234 GiB\\\" available in \\\"topology.kubernetes.io/zone=us-east1\\\" - StorageClass \\\"localssd\\\" has \\\"10 GiB\\\" available in \\\"kubernetes.io/hostname=knode-abc123\\\"\\n\\nThe following three cases all imply that no capacity is available for a certain combination: - no object exists with suitable topology and storage class name - such an object exists, but the capacity is unset - such an object exists, but the capacity is zero\\n\\nThe producer of these objects can decide which approach is more suitable.\\n\\nThey are consumed by the kube-scheduler when a CSI driver opts into capacity-aware scheduling with CSIDriverSpec.StorageCapacity. The scheduler compares the MaximumVolumeSize against the requested size of pending volumes to filter out unsuitable nodes. If MaximumVolumeSize is unset, it falls back to a comparison against the less precise Capacity. If that is also unset, the scheduler assumes that capacity is insufficient and tries some other node.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"capacity\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"maximumVolumeSize\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"nodeTopology\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"storageClassName\":{\"default\":\"\",\"description\":\"storageClassName represents the name of the StorageClass that the reported capacity applies to. It must meet the same requirements as the name of a StorageClass object (non-empty, DNS subdomain). If that object no longer exists, the CSIStorageCapacity object is obsolete and should be removed by its creator. This field is immutable.\",\"type\":\"string\"}},\"required\":[\"storageClassName\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.CSIStorageCapacityList\":{\"description\":\"CSIStorageCapacityList is a collection of CSIStorageCapacity objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of CSIStorageCapacity objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacityList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.StorageClass\":{\"description\":\"StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned.\\n\\nStorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name.\",\"properties\":{\"allowVolumeExpansion\":{\"description\":\"allowVolumeExpansion shows whether the storage class allow volume expand.\",\"type\":\"boolean\"},\"allowedTopologies\":{\"description\":\"allowedTopologies restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"mountOptions\":{\"description\":\"mountOptions controls the mountOptions for dynamically provisioned PersistentVolumes of this storage class. e.g. [\\\"ro\\\", \\\"soft\\\"]. Not validated - mount of the PVs will simply fail if one is invalid.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"parameters\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"parameters holds the parameters for the provisioner that should create volumes of this storage class.\",\"type\":\"object\"},\"provisioner\":{\"default\":\"\",\"description\":\"provisioner indicates the type of the provisioner.\",\"type\":\"string\"},\"reclaimPolicy\":{\"description\":\"reclaimPolicy controls the reclaimPolicy for dynamically provisioned PersistentVolumes of this storage class. Defaults to Delete.\",\"type\":\"string\"},\"volumeBindingMode\":{\"description\":\"volumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature.\",\"type\":\"string\"}},\"required\":[\"provisioner\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.StorageClassList\":{\"description\":\"StorageClassList is a collection of storage classes.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of StorageClasses\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClassList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.TokenRequest\":{\"description\":\"TokenRequest contains parameters of a service account token.\",\"properties\":{\"audience\":{\"default\":\"\",\"description\":\"audience is the intended audience of the token in \\\"TokenRequestSpec\\\". It will default to the audiences of kube apiserver.\",\"type\":\"string\"},\"expirationSeconds\":{\"description\":\"expirationSeconds is the duration of validity of the token in \\\"TokenRequestSpec\\\". It has the same default value of \\\"ExpirationSeconds\\\" in \\\"TokenRequestSpec\\\".\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"audience\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.VolumeAttachment\":{\"description\":\"VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node.\\n\\nVolumeAttachment objects are non-namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.VolumeAttachmentList\":{\"description\":\"VolumeAttachmentList is a collection of VolumeAttachment objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of VolumeAttachments\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachmentList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.VolumeAttachmentSource\":{\"description\":\"VolumeAttachmentSource represents a volume that should be attached. Right now only PersistentVolumes can be attached via external attacher, in the future we may allow also inline volumes in pods. Exactly one member can be set.\",\"properties\":{\"inlineVolumeSpec\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec\"},\"persistentVolumeName\":{\"description\":\"persistentVolumeName represents the name of the persistent volume to attach.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.storage.v1.VolumeAttachmentSpec\":{\"description\":\"VolumeAttachmentSpec is the specification of a VolumeAttachment request.\",\"properties\":{\"attacher\":{\"default\":\"\",\"description\":\"attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName().\",\"type\":\"string\"},\"nodeName\":{\"default\":\"\",\"description\":\"nodeName represents the node that the volume should be attached to.\",\"type\":\"string\"},\"source\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource\"}},\"required\":[\"attacher\",\"source\",\"nodeName\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.VolumeAttachmentStatus\":{\"description\":\"VolumeAttachmentStatus is the status of a VolumeAttachment request.\",\"properties\":{\"attachError\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeError\"},\"attached\":{\"default\":false,\"description\":\"attached indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.\",\"type\":\"boolean\"},\"attachmentMetadata\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"attachmentMetadata is populated with any information returned by the attach operation, upon successful attach, that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher.\",\"type\":\"object\"},\"detachError\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeError\"}},\"required\":[\"attached\"],\"type\":\"object\"},\"io.k8s.api.storage.v1.VolumeAttributesClass\":{\"description\":\"VolumeAttributesClass represents a specification of mutable volume attributes defined by the CSI driver. The class can be specified during dynamic provisioning of PersistentVolumeClaims, and changed in the PersistentVolumeClaim spec after provisioning.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"driverName\":{\"default\":\"\",\"description\":\"Name of the CSI driver This field is immutable.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"parameters\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"parameters hold volume attributes defined by the CSI driver. These values are opaque to the Kubernetes and are passed directly to the CSI driver. The underlying storage provider supports changing these attributes on an existing volume, however the parameters field itself is immutable. To invoke a volume update, a new VolumeAttributesClass should be created with new parameters, and the PersistentVolumeClaim should be updated to reference the new VolumeAttributesClass.\\n\\nThis field is required and must contain at least one key/value pair. The keys cannot be empty, and the maximum number of parameters is 512, with a cumulative max size of 256K. If the CSI driver rejects invalid parameters, the target PersistentVolumeClaim will be set to an \\\"Infeasible\\\" state in the modifyVolumeStatus field.\",\"type\":\"object\"}},\"required\":[\"driverName\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.VolumeAttributesClassList\":{\"description\":\"VolumeAttributesClassList is a collection of VolumeAttributesClass objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is the list of VolumeAttributesClass objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClassList\",\"version\":\"v1\"}]},\"io.k8s.api.storage.v1.VolumeError\":{\"description\":\"VolumeError captures an error encountered during a volume operation.\",\"properties\":{\"errorCode\":{\"description\":\"errorCode is a numeric gRPC code representing the error encountered during Attach or Detach operations.\\n\\nThis is an optional, beta field that requires the MutableCSINodeAllocatableCount feature gate being enabled to be set.\",\"format\":\"int32\",\"type\":\"integer\"},\"message\":{\"description\":\"message represents the error encountered during Attach or Detach operation. This string may be logged, so it should not contain sensitive information.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.api.storage.v1.VolumeNodeResources\":{\"description\":\"VolumeNodeResources is a set of resource limits for scheduling of volumes.\",\"properties\":{\"count\":{\"description\":\"count indicates the maximum number of unique volumes managed by the CSI driver that can be used on a node. A volume that is both attached and mounted on a node is considered to be used once, not twice. The same rule applies for a unique volume that is shared among multiple pods on the same node. If this field is not specified, then the supported number of volumes on this node is unbounded.\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/apis/storage.k8s.io/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getStorageV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"]}},\"/apis/storage.k8s.io/v1/csidrivers\":{\"delete\":{\"description\":\"delete collection of CSIDriver\",\"operationId\":\"deleteStorageV1CollectionCSIDriver\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CSIDriver\",\"operationId\":\"listStorageV1CSIDriver\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriverList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CSIDriver\",\"operationId\":\"createStorageV1CSIDriver\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/csidrivers/{name}\":{\"delete\":{\"description\":\"delete a CSIDriver\",\"operationId\":\"deleteStorageV1CSIDriver\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CSIDriver\",\"operationId\":\"readStorageV1CSIDriver\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CSIDriver\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CSIDriver\",\"operationId\":\"patchStorageV1CSIDriver\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CSIDriver\",\"operationId\":\"replaceStorageV1CSIDriver\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIDriver\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/csinodes\":{\"delete\":{\"description\":\"delete collection of CSINode\",\"operationId\":\"deleteStorageV1CollectionCSINode\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CSINode\",\"operationId\":\"listStorageV1CSINode\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINodeList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CSINode\",\"operationId\":\"createStorageV1CSINode\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/csinodes/{name}\":{\"delete\":{\"description\":\"delete a CSINode\",\"operationId\":\"deleteStorageV1CSINode\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CSINode\",\"operationId\":\"readStorageV1CSINode\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CSINode\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CSINode\",\"operationId\":\"patchStorageV1CSINode\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CSINode\",\"operationId\":\"replaceStorageV1CSINode\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSINode\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/csistoragecapacities\":{\"get\":{\"description\":\"list or watch objects of kind CSIStorageCapacity\",\"operationId\":\"listStorageV1CSIStorageCapacityForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities\":{\"delete\":{\"description\":\"delete collection of CSIStorageCapacity\",\"operationId\":\"deleteStorageV1CollectionNamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind CSIStorageCapacity\",\"operationId\":\"listStorageV1NamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a CSIStorageCapacity\",\"operationId\":\"createStorageV1NamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}\":{\"delete\":{\"description\":\"delete a CSIStorageCapacity\",\"operationId\":\"deleteStorageV1NamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified CSIStorageCapacity\",\"operationId\":\"readStorageV1NamespacedCSIStorageCapacity\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the CSIStorageCapacity\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified CSIStorageCapacity\",\"operationId\":\"patchStorageV1NamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified CSIStorageCapacity\",\"operationId\":\"replaceStorageV1NamespacedCSIStorageCapacity\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/storageclasses\":{\"delete\":{\"description\":\"delete collection of StorageClass\",\"operationId\":\"deleteStorageV1CollectionStorageClass\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind StorageClass\",\"operationId\":\"listStorageV1StorageClass\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClassList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a StorageClass\",\"operationId\":\"createStorageV1StorageClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/storageclasses/{name}\":{\"delete\":{\"description\":\"delete a StorageClass\",\"operationId\":\"deleteStorageV1StorageClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified StorageClass\",\"operationId\":\"readStorageV1StorageClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the StorageClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified StorageClass\",\"operationId\":\"patchStorageV1StorageClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified StorageClass\",\"operationId\":\"replaceStorageV1StorageClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.StorageClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/volumeattachments\":{\"delete\":{\"description\":\"delete collection of VolumeAttachment\",\"operationId\":\"deleteStorageV1CollectionVolumeAttachment\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind VolumeAttachment\",\"operationId\":\"listStorageV1VolumeAttachment\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a VolumeAttachment\",\"operationId\":\"createStorageV1VolumeAttachment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/volumeattachments/{name}\":{\"delete\":{\"description\":\"delete a VolumeAttachment\",\"operationId\":\"deleteStorageV1VolumeAttachment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified VolumeAttachment\",\"operationId\":\"readStorageV1VolumeAttachment\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the VolumeAttachment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified VolumeAttachment\",\"operationId\":\"patchStorageV1VolumeAttachment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified VolumeAttachment\",\"operationId\":\"replaceStorageV1VolumeAttachment\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/volumeattachments/{name}/status\":{\"get\":{\"description\":\"read status of the specified VolumeAttachment\",\"operationId\":\"readStorageV1VolumeAttachmentStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the VolumeAttachment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified VolumeAttachment\",\"operationId\":\"patchStorageV1VolumeAttachmentStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified VolumeAttachment\",\"operationId\":\"replaceStorageV1VolumeAttachmentStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttachment\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/volumeattributesclasses\":{\"delete\":{\"description\":\"delete collection of VolumeAttributesClass\",\"operationId\":\"deleteStorageV1CollectionVolumeAttributesClass\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind VolumeAttributesClass\",\"operationId\":\"listStorageV1VolumeAttributesClass\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a VolumeAttributesClass\",\"operationId\":\"createStorageV1VolumeAttributesClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/volumeattributesclasses/{name}\":{\"delete\":{\"description\":\"delete a VolumeAttributesClass\",\"operationId\":\"deleteStorageV1VolumeAttributesClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified VolumeAttributesClass\",\"operationId\":\"readStorageV1VolumeAttributesClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the VolumeAttributesClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified VolumeAttributesClass\",\"operationId\":\"patchStorageV1VolumeAttributesClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified VolumeAttributesClass\",\"operationId\":\"replaceStorageV1VolumeAttributesClass\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}}},\"/apis/storage.k8s.io/v1/watch/csidrivers\":{\"get\":{\"description\":\"watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1CSIDriverList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/csidrivers/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1CSIDriver\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIDriver\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CSIDriver\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/csinodes\":{\"get\":{\"description\":\"watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1CSINodeList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/csinodes/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1CSINode\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSINode\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CSINode\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/csistoragecapacities\":{\"get\":{\"description\":\"watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1CSIStorageCapacityListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities\":{\"get\":{\"description\":\"watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1NamespacedCSIStorageCapacityList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1NamespacedCSIStorageCapacity\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"CSIStorageCapacity\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the CSIStorageCapacity\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/storageclasses\":{\"get\":{\"description\":\"watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1StorageClassList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/storageclasses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1StorageClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"StorageClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the StorageClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/volumeattachments\":{\"get\":{\"description\":\"watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1VolumeAttachmentList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/volumeattachments/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1VolumeAttachment\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttachment\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the VolumeAttachment\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/volumeattributesclasses\":{\"get\":{\"description\":\"watch individual changes to a list of VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchStorageV1VolumeAttributesClassList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/apis/storage.k8s.io/v1/watch/volumeattributesclasses/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchStorageV1VolumeAttributesClass\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-3214defad8ecff6cb055.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"storage_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"storage.k8s.io\",\"kind\":\"VolumeAttributesClass\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the VolumeAttributesClass\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriver", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINode", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeDriver", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClass", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClassList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.TokenRequest", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachment", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeError", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, value) = _decode(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureDiskVolumeSource + cachingmode::Union{Absent,Nothing,String} = ABSENT + diskname::String + diskuri::String + fstype::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureDiskVolumeSource") + _openapi_field_cachingmode = haskey(_openapi_object, "cachingMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["cachingMode"], _openapi_validate) : ABSENT + _openapi_field_diskname = _decode(String, _required(_openapi_object, "diskName", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_diskuri = _decode(String, _required(_openapi_object, "diskURI", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cachingMode","diskName","diskURI","fsType","kind","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureDiskVolumeSource(; cachingmode = _openapi_field_cachingmode, diskname = _openapi_field_diskname, diskuri = _openapi_field_diskuri, fstype = _openapi_field_fstype, kind = _openapi_field_kind, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cachingmode isa Absent || (_openapi_output["cachingMode"] = _encode(_openapi_value.cachingmode)) + _openapi_value.diskname isa Absent || (_openapi_output["diskName"] = _encode(_openapi_value.diskname)) + _openapi_value.diskuri isa Absent || (_openapi_output["diskURI"] = _encode(_openapi_value.diskuri)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.cachingmode isa Absent || push!(_openapi_output, "cachingMode" => _openapi_value.cachingmode) + _openapi_value.diskname isa Absent || push!(_openapi_output, "diskName" => _openapi_value.diskname) + _openapi_value.diskuri isa Absent || push!(_openapi_output, "diskURI" => _openapi_value.diskuri) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureFilePersistentVolumeSource + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretname::String + secretnamespace::Union{Absent,Nothing,String} = ABSENT + sharename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureFilePersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureFilePersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureFilePersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureFilePersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureFilePersistentVolumeSource") + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretname = _decode(String, _required(_openapi_object, "secretName", "IoK8sApiCoreV1AzureFilePersistentVolumeSource"), _openapi_validate) + _openapi_field_secretnamespace = haskey(_openapi_object, "secretNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretNamespace"], _openapi_validate) : ABSENT + _openapi_field_sharename = _decode(String, _required(_openapi_object, "shareName", "IoK8sApiCoreV1AzureFilePersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("readOnly","secretName","secretNamespace","shareName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureFilePersistentVolumeSource(; readonly = _openapi_field_readonly, secretname = _openapi_field_secretname, secretnamespace = _openapi_field_secretnamespace, sharename = _openapi_field_sharename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureFilePersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + _openapi_value.secretnamespace isa Absent || (_openapi_output["secretNamespace"] = _encode(_openapi_value.secretnamespace)) + _openapi_value.sharename isa Absent || (_openapi_output["shareName"] = _encode(_openapi_value.sharename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureFilePersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureFilePersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + _openapi_value.secretnamespace isa Absent || push!(_openapi_output, "secretNamespace" => _openapi_value.secretnamespace) + _openapi_value.sharename isa Absent || push!(_openapi_output, "shareName" => _openapi_value.sharename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretReference + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretReference}, value) = _decode(IoK8sApiCoreV1SecretReference, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference"), _openapi_raw, "decoding IoK8sApiCoreV1SecretReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretReference(; name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference"), _openapi_output, "encoding IoK8sApiCoreV1SecretReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes}, value) = _decode(IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource/properties/volumeAttributes"), _openapi_raw, "decoding IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource/properties/volumeAttributes"), _openapi_output, "encoding IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIPersistentVolumeSource + controllerexpandsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + controllerpublishsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + nodeexpandsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + nodepublishsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + nodestagesecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeattributes::Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes,Nothing} = ABSENT + volumehandle::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CSIPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CSIPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIPersistentVolumeSource") + _openapi_field_controllerexpandsecretref = haskey(_openapi_object, "controllerExpandSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["controllerExpandSecretRef"], _openapi_validate) : ABSENT + _openapi_field_controllerpublishsecretref = haskey(_openapi_object, "controllerPublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["controllerPublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1CSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_nodeexpandsecretref = haskey(_openapi_object, "nodeExpandSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodeExpandSecretRef"], _openapi_validate) : ABSENT + _openapi_field_nodepublishsecretref = haskey(_openapi_object, "nodePublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodePublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_nodestagesecretref = haskey(_openapi_object, "nodeStageSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodeStageSecretRef"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeattributes = haskey(_openapi_object, "volumeAttributes") ? _decode(Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes,Nothing}, _openapi_object["volumeAttributes"], _openapi_validate) : ABSENT + _openapi_field_volumehandle = _decode(String, _required(_openapi_object, "volumeHandle", "IoK8sApiCoreV1CSIPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("controllerExpandSecretRef","controllerPublishSecretRef","driver","fsType","nodeExpandSecretRef","nodePublishSecretRef","nodeStageSecretRef","readOnly","volumeAttributes","volumeHandle") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIPersistentVolumeSource(; controllerexpandsecretref = _openapi_field_controllerexpandsecretref, controllerpublishsecretref = _openapi_field_controllerpublishsecretref, driver = _openapi_field_driver, fstype = _openapi_field_fstype, nodeexpandsecretref = _openapi_field_nodeexpandsecretref, nodepublishsecretref = _openapi_field_nodepublishsecretref, nodestagesecretref = _openapi_field_nodestagesecretref, readonly = _openapi_field_readonly, volumeattributes = _openapi_field_volumeattributes, volumehandle = _openapi_field_volumehandle, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.controllerexpandsecretref isa Absent || (_openapi_output["controllerExpandSecretRef"] = _encode(_openapi_value.controllerexpandsecretref)) + _openapi_value.controllerpublishsecretref isa Absent || (_openapi_output["controllerPublishSecretRef"] = _encode(_openapi_value.controllerpublishsecretref)) + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.nodeexpandsecretref isa Absent || (_openapi_output["nodeExpandSecretRef"] = _encode(_openapi_value.nodeexpandsecretref)) + _openapi_value.nodepublishsecretref isa Absent || (_openapi_output["nodePublishSecretRef"] = _encode(_openapi_value.nodepublishsecretref)) + _openapi_value.nodestagesecretref isa Absent || (_openapi_output["nodeStageSecretRef"] = _encode(_openapi_value.nodestagesecretref)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeattributes isa Absent || (_openapi_output["volumeAttributes"] = _encode(_openapi_value.volumeattributes)) + _openapi_value.volumehandle isa Absent || (_openapi_output["volumeHandle"] = _encode(_openapi_value.volumehandle)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CSIPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.controllerexpandsecretref isa Absent || push!(_openapi_output, "controllerExpandSecretRef" => _openapi_value.controllerexpandsecretref) + _openapi_value.controllerpublishsecretref isa Absent || push!(_openapi_output, "controllerPublishSecretRef" => _openapi_value.controllerpublishsecretref) + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.nodeexpandsecretref isa Absent || push!(_openapi_output, "nodeExpandSecretRef" => _openapi_value.nodeexpandsecretref) + _openapi_value.nodepublishsecretref isa Absent || push!(_openapi_output, "nodePublishSecretRef" => _openapi_value.nodepublishsecretref) + _openapi_value.nodestagesecretref isa Absent || push!(_openapi_output, "nodeStageSecretRef" => _openapi_value.nodestagesecretref) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeattributes isa Absent || push!(_openapi_output, "volumeAttributes" => _openapi_value.volumeattributes) + _openapi_value.volumehandle isa Absent || push!(_openapi_output, "volumeHandle" => _openapi_value.volumehandle) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CephFSPersistentVolumeSource + monitors::Union{Nothing,Vector{String}} + path::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretfile::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CephFSPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CephFSPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CephFSPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CephFSPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CephFSPersistentVolumeSource") + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1CephFSPersistentVolumeSource"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretfile = haskey(_openapi_object, "secretFile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretFile"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("monitors","path","readOnly","secretFile","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CephFSPersistentVolumeSource(; monitors = _openapi_field_monitors, path = _openapi_field_path, readonly = _openapi_field_readonly, secretfile = _openapi_field_secretfile, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CephFSPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretfile isa Absent || (_openapi_output["secretFile"] = _encode(_openapi_value.secretfile)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CephFSPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CephFSPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretfile isa Absent || push!(_openapi_output, "secretFile" => _openapi_value.secretfile) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CinderPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CinderPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CinderPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CinderPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CinderPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CinderPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1CinderPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CinderPersistentVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CinderPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CinderPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CinderPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FCVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + lun::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + targetwwns::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + wwids::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FCVolumeSource}, value) = _decode(IoK8sApiCoreV1FCVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FCVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FCVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_lun = haskey(_openapi_object, "lun") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["lun"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_targetwwns = haskey(_openapi_object, "targetWWNs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["targetWWNs"], _openapi_validate) : ABSENT + _openapi_field_wwids = haskey(_openapi_object, "wwids") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["wwids"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","lun","readOnly","targetWWNs","wwids") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FCVolumeSource(; fstype = _openapi_field_fstype, lun = _openapi_field_lun, readonly = _openapi_field_readonly, targetwwns = _openapi_field_targetwwns, wwids = _openapi_field_wwids, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.targetwwns isa Absent || (_openapi_output["targetWWNs"] = _encode(_openapi_value.targetwwns)) + _openapi_value.wwids isa Absent || (_openapi_output["wwids"] = _encode(_openapi_value.wwids)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.targetwwns isa Absent || push!(_openapi_output, "targetWWNs" => _openapi_value.targetwwns) + _openapi_value.wwids isa Absent || push!(_openapi_output, "wwids" => _openapi_value.wwids) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexPersistentVolumeSourceOptions + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSourceOptions}, value) = _decode(IoK8sApiCoreV1FlexPersistentVolumeSourceOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSourceOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource/properties/options"), _openapi_raw, "decoding IoK8sApiCoreV1FlexPersistentVolumeSourceOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexPersistentVolumeSourceOptions") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexPersistentVolumeSourceOptions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSourceOptions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource/properties/options"), _openapi_output, "encoding IoK8sApiCoreV1FlexPersistentVolumeSourceOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSourceOptions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexPersistentVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + options::Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSourceOptions,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1FlexPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlexPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexPersistentVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1FlexPersistentVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSourceOptions,Nothing}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","options","readOnly","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexPersistentVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, options = _openapi_field_options, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlexPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlockerVolumeSource + datasetname::Union{Absent,Nothing,String} = ABSENT + datasetuuid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, value) = _decode(IoK8sApiCoreV1FlockerVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlockerVolumeSource") + _openapi_field_datasetname = haskey(_openapi_object, "datasetName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetName"], _openapi_validate) : ABSENT + _openapi_field_datasetuuid = haskey(_openapi_object, "datasetUUID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetUUID"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("datasetName","datasetUUID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlockerVolumeSource(; datasetname = _openapi_field_datasetname, datasetuuid = _openapi_field_datasetuuid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.datasetname isa Absent || (_openapi_output["datasetName"] = _encode(_openapi_value.datasetname)) + _openapi_value.datasetuuid isa Absent || (_openapi_output["datasetUUID"] = _encode(_openapi_value.datasetuuid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.datasetname isa Absent || push!(_openapi_output, "datasetName" => _openapi_value.datasetname) + _openapi_value.datasetuuid isa Absent || push!(_openapi_output, "datasetUUID" => _openapi_value.datasetuuid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GCEPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + pdname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GCEPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_pdname = _decode(String, _required(_openapi_object, "pdName", "IoK8sApiCoreV1GCEPersistentDiskVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","pdName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GCEPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, pdname = _openapi_field_pdname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.pdname isa Absent || (_openapi_output["pdName"] = _encode(_openapi_value.pdname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.pdname isa Absent || push!(_openapi_output, "pdName" => _openapi_value.pdname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GlusterfsPersistentVolumeSource + endpoints::String + endpointsnamespace::Union{Absent,Nothing,String} = ABSENT + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GlusterfsPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GlusterfsPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GlusterfsPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GlusterfsPersistentVolumeSource") + _openapi_field_endpoints = _decode(String, _required(_openapi_object, "endpoints", "IoK8sApiCoreV1GlusterfsPersistentVolumeSource"), _openapi_validate) + _openapi_field_endpointsnamespace = haskey(_openapi_object, "endpointsNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["endpointsNamespace"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1GlusterfsPersistentVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endpoints","endpointsNamespace","path","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GlusterfsPersistentVolumeSource(; endpoints = _openapi_field_endpoints, endpointsnamespace = _openapi_field_endpointsnamespace, path = _openapi_field_path, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GlusterfsPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.endpointsnamespace isa Absent || (_openapi_output["endpointsNamespace"] = _encode(_openapi_value.endpointsnamespace)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GlusterfsPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GlusterfsPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.endpointsnamespace isa Absent || push!(_openapi_output, "endpointsNamespace" => _openapi_value.endpointsnamespace) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostPathVolumeSource + path::String + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, value) = _decode(IoK8sApiCoreV1HostPathVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostPathVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1HostPathVolumeSource"), _openapi_validate) + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostPathVolumeSource(; path = _openapi_field_path, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ISCSIPersistentVolumeSource + chapauthdiscovery::Union{Absent,Bool,Nothing} = ABSENT + chapauthsession::Union{Absent,Bool,Nothing} = ABSENT + fstype::Union{Absent,Nothing,String} = ABSENT + initiatorname::Union{Absent,Nothing,String} = ABSENT + iqn::String + iscsiinterface::Union{Absent,Nothing,String} = ABSENT + lun::Int32 + portals::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + targetportal::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ISCSIPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1ISCSIPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ISCSIPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ISCSIPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ISCSIPersistentVolumeSource") + _openapi_field_chapauthdiscovery = haskey(_openapi_object, "chapAuthDiscovery") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthDiscovery"], _openapi_validate) : ABSENT + _openapi_field_chapauthsession = haskey(_openapi_object, "chapAuthSession") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthSession"], _openapi_validate) : ABSENT + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_initiatorname = haskey(_openapi_object, "initiatorName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["initiatorName"], _openapi_validate) : ABSENT + _openapi_field_iqn = _decode(String, _required(_openapi_object, "iqn", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_iscsiinterface = haskey(_openapi_object, "iscsiInterface") ? _decode(Union{Absent,Nothing,String}, _openapi_object["iscsiInterface"], _openapi_validate) : ABSENT + _openapi_field_lun = _decode(Int32, _required(_openapi_object, "lun", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_portals = haskey(_openapi_object, "portals") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["portals"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_targetportal = _decode(String, _required(_openapi_object, "targetPortal", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("chapAuthDiscovery","chapAuthSession","fsType","initiatorName","iqn","iscsiInterface","lun","portals","readOnly","secretRef","targetPortal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ISCSIPersistentVolumeSource(; chapauthdiscovery = _openapi_field_chapauthdiscovery, chapauthsession = _openapi_field_chapauthsession, fstype = _openapi_field_fstype, initiatorname = _openapi_field_initiatorname, iqn = _openapi_field_iqn, iscsiinterface = _openapi_field_iscsiinterface, lun = _openapi_field_lun, portals = _openapi_field_portals, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, targetportal = _openapi_field_targetportal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ISCSIPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.chapauthdiscovery isa Absent || (_openapi_output["chapAuthDiscovery"] = _encode(_openapi_value.chapauthdiscovery)) + _openapi_value.chapauthsession isa Absent || (_openapi_output["chapAuthSession"] = _encode(_openapi_value.chapauthsession)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.initiatorname isa Absent || (_openapi_output["initiatorName"] = _encode(_openapi_value.initiatorname)) + _openapi_value.iqn isa Absent || (_openapi_output["iqn"] = _encode(_openapi_value.iqn)) + _openapi_value.iscsiinterface isa Absent || (_openapi_output["iscsiInterface"] = _encode(_openapi_value.iscsiinterface)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.portals isa Absent || (_openapi_output["portals"] = _encode(_openapi_value.portals)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.targetportal isa Absent || (_openapi_output["targetPortal"] = _encode(_openapi_value.targetportal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ISCSIPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ISCSIPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.chapauthdiscovery isa Absent || push!(_openapi_output, "chapAuthDiscovery" => _openapi_value.chapauthdiscovery) + _openapi_value.chapauthsession isa Absent || push!(_openapi_output, "chapAuthSession" => _openapi_value.chapauthsession) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.initiatorname isa Absent || push!(_openapi_output, "initiatorName" => _openapi_value.initiatorname) + _openapi_value.iqn isa Absent || push!(_openapi_output, "iqn" => _openapi_value.iqn) + _openapi_value.iscsiinterface isa Absent || push!(_openapi_output, "iscsiInterface" => _openapi_value.iscsiinterface) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.portals isa Absent || push!(_openapi_output, "portals" => _openapi_value.portals) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.targetportal isa Absent || push!(_openapi_output, "targetPortal" => _openapi_value.targetportal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LocalVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LocalVolumeSource}, value) = _decode(IoK8sApiCoreV1LocalVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1LocalVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1LocalVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LocalVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1LocalVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LocalVolumeSource(; fstype = _openapi_field_fstype, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LocalVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1LocalVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LocalVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NFSVolumeSource + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + server::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, value) = _decode(IoK8sApiCoreV1NFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NFSVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_server = _decode(String, _required(_openapi_object, "server", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","readOnly","server") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NFSVolumeSource(; path = _openapi_field_path, readonly = _openapi_field_readonly, server = _openapi_field_server, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.server isa Absent || (_openapi_output["server"] = _encode(_openapi_value.server)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.server isa Absent || push!(_openapi_output, "server" => _openapi_value.server) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, value) = _decode(IoK8sApiCoreV1NodeSelectorRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorTerm + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + matchfields::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, value) = _decode(IoK8sApiCoreV1NodeSelectorTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorTerm") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchfields = haskey(_openapi_object, "matchFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchFields"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchFields") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorTerm(; matchexpressions = _openapi_field_matchexpressions, matchfields = _openapi_field_matchfields, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchfields isa Absent || (_openapi_output["matchFields"] = _encode(_openapi_value.matchfields)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchfields isa Absent || push!(_openapi_output, "matchFields" => _openapi_value.matchfields) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelector + nodeselectorterms::Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelector}, value) = _decode(IoK8sApiCoreV1NodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelector") + _openapi_field_nodeselectorterms = _decode(Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}}, _required(_openapi_object, "nodeSelectorTerms", "IoK8sApiCoreV1NodeSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeSelectorTerms",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelector(; nodeselectorterms = _openapi_field_nodeselectorterms, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeselectorterms isa Absent || (_openapi_output["nodeSelectorTerms"] = _encode(_openapi_value.nodeselectorterms)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeselectorterms isa Absent || push!(_openapi_output, "nodeSelectorTerms" => _openapi_value.nodeselectorterms) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectReference}, value) = _decode(IoK8sApiCoreV1ObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath","kind","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectReference(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeSpecCapacity + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeSpecCapacity}, value) = _decode(IoK8sApiCoreV1PersistentVolumeSpecCapacity, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeSpecCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec/properties/capacity"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeSpecCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeSpecCapacity") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeSpecCapacity(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpecCapacity) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec/properties/capacity"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeSpecCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpecCapacity) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeNodeAffinity + required::Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeNodeAffinity}, value) = _decode(IoK8sApiCoreV1VolumeNodeAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeNodeAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeNodeAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeNodeAffinity") + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("required",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeNodeAffinity(; required = _openapi_field_required, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeNodeAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity"), _openapi_output, "encoding IoK8sApiCoreV1VolumeNodeAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeNodeAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PhotonPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + pdid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_pdid = _decode(String, _required(_openapi_object, "pdID", "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","pdID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, pdid = _openapi_field_pdid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.pdid isa Absent || (_openapi_output["pdID"] = _encode(_openapi_value.pdid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.pdid isa Absent || push!(_openapi_output, "pdID" => _openapi_value.pdid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PortworxVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, value) = _decode(IoK8sApiCoreV1PortworxVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PortworxVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1PortworxVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PortworxVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1QuobyteVolumeSource + group::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + registry::String + tenant::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + volume::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, value) = _decode(IoK8sApiCoreV1QuobyteVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1QuobyteVolumeSource") + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_registry = _decode(String, _required(_openapi_object, "registry", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_field_tenant = haskey(_openapi_object, "tenant") ? _decode(Union{Absent,Nothing,String}, _openapi_object["tenant"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_field_volume = _decode(String, _required(_openapi_object, "volume", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("group","readOnly","registry","tenant","user","volume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1QuobyteVolumeSource(; group = _openapi_field_group, readonly = _openapi_field_readonly, registry = _openapi_field_registry, tenant = _openapi_field_tenant, user = _openapi_field_user, volume = _openapi_field_volume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.registry isa Absent || (_openapi_output["registry"] = _encode(_openapi_value.registry)) + _openapi_value.tenant isa Absent || (_openapi_output["tenant"] = _encode(_openapi_value.tenant)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + _openapi_value.volume isa Absent || (_openapi_output["volume"] = _encode(_openapi_value.volume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.registry isa Absent || push!(_openapi_output, "registry" => _openapi_value.registry) + _openapi_value.tenant isa Absent || push!(_openapi_output, "tenant" => _openapi_value.tenant) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + _openapi_value.volume isa Absent || push!(_openapi_output, "volume" => _openapi_value.volume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1RBDPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + image::String + keyring::Union{Absent,Nothing,String} = ABSENT + monitors::Union{Nothing,Vector{String}} + pool::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1RBDPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1RBDPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1RBDPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1RBDPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1RBDPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1RBDPersistentVolumeSource"), _openapi_validate) + _openapi_field_keyring = haskey(_openapi_object, "keyring") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyring"], _openapi_validate) : ABSENT + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1RBDPersistentVolumeSource"), _openapi_validate) + _openapi_field_pool = haskey(_openapi_object, "pool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pool"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","image","keyring","monitors","pool","readOnly","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1RBDPersistentVolumeSource(; fstype = _openapi_field_fstype, image = _openapi_field_image, keyring = _openapi_field_keyring, monitors = _openapi_field_monitors, pool = _openapi_field_pool, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1RBDPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.keyring isa Absent || (_openapi_output["keyring"] = _encode(_openapi_value.keyring)) + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.pool isa Absent || (_openapi_output["pool"] = _encode(_openapi_value.pool)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1RBDPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1RBDPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.keyring isa Absent || push!(_openapi_output, "keyring" => _openapi_value.keyring) + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.pool isa Absent || push!(_openapi_output, "pool" => _openapi_value.pool) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScaleIOPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + gateway::String + protectiondomain::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::IoK8sApiCoreV1SecretReference + sslenabled::Union{Absent,Bool,Nothing} = ABSENT + storagemode::Union{Absent,Nothing,String} = ABSENT + storagepool::Union{Absent,Nothing,String} = ABSENT + system::String + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScaleIOPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ScaleIOPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ScaleIOPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScaleIOPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_gateway = _decode(String, _required(_openapi_object, "gateway", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_protectiondomain = haskey(_openapi_object, "protectionDomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protectionDomain"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = _decode(IoK8sApiCoreV1SecretReference, _required(_openapi_object, "secretRef", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_sslenabled = haskey(_openapi_object, "sslEnabled") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["sslEnabled"], _openapi_validate) : ABSENT + _openapi_field_storagemode = haskey(_openapi_object, "storageMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageMode"], _openapi_validate) : ABSENT + _openapi_field_storagepool = haskey(_openapi_object, "storagePool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePool"], _openapi_validate) : ABSENT + _openapi_field_system = _decode(String, _required(_openapi_object, "system", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","gateway","protectionDomain","readOnly","secretRef","sslEnabled","storageMode","storagePool","system","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScaleIOPersistentVolumeSource(; fstype = _openapi_field_fstype, gateway = _openapi_field_gateway, protectiondomain = _openapi_field_protectiondomain, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, sslenabled = _openapi_field_sslenabled, storagemode = _openapi_field_storagemode, storagepool = _openapi_field_storagepool, system = _openapi_field_system, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScaleIOPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.gateway isa Absent || (_openapi_output["gateway"] = _encode(_openapi_value.gateway)) + _openapi_value.protectiondomain isa Absent || (_openapi_output["protectionDomain"] = _encode(_openapi_value.protectiondomain)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.sslenabled isa Absent || (_openapi_output["sslEnabled"] = _encode(_openapi_value.sslenabled)) + _openapi_value.storagemode isa Absent || (_openapi_output["storageMode"] = _encode(_openapi_value.storagemode)) + _openapi_value.storagepool isa Absent || (_openapi_output["storagePool"] = _encode(_openapi_value.storagepool)) + _openapi_value.system isa Absent || (_openapi_output["system"] = _encode(_openapi_value.system)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ScaleIOPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScaleIOPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.gateway isa Absent || push!(_openapi_output, "gateway" => _openapi_value.gateway) + _openapi_value.protectiondomain isa Absent || push!(_openapi_output, "protectionDomain" => _openapi_value.protectiondomain) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.sslenabled isa Absent || push!(_openapi_output, "sslEnabled" => _openapi_value.sslenabled) + _openapi_value.storagemode isa Absent || push!(_openapi_output, "storageMode" => _openapi_value.storagemode) + _openapi_value.storagepool isa Absent || push!(_openapi_output, "storagePool" => _openapi_value.storagepool) + _openapi_value.system isa Absent || push!(_openapi_output, "system" => _openapi_value.system) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1StorageOSPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + volumenamespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1StorageOSPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1StorageOSPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1StorageOSPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1StorageOSPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1StorageOSPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_field_volumenamespace = haskey(_openapi_object, "volumeNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeNamespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeName","volumeNamespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1StorageOSPersistentVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumename = _openapi_field_volumename, volumenamespace = _openapi_field_volumenamespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1StorageOSPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + _openapi_value.volumenamespace isa Absent || (_openapi_output["volumeNamespace"] = _encode(_openapi_value.volumenamespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1StorageOSPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1StorageOSPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + _openapi_value.volumenamespace isa Absent || push!(_openapi_output, "volumeNamespace" => _openapi_value.volumenamespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VsphereVirtualDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + storagepolicyid::Union{Absent,Nothing,String} = ABSENT + storagepolicyname::Union{Absent,Nothing,String} = ABSENT + volumepath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyid = haskey(_openapi_object, "storagePolicyID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyID"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyname = haskey(_openapi_object, "storagePolicyName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyName"], _openapi_validate) : ABSENT + _openapi_field_volumepath = _decode(String, _required(_openapi_object, "volumePath", "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","storagePolicyID","storagePolicyName","volumePath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(; fstype = _openapi_field_fstype, storagepolicyid = _openapi_field_storagepolicyid, storagepolicyname = _openapi_field_storagepolicyname, volumepath = _openapi_field_volumepath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.storagepolicyid isa Absent || (_openapi_output["storagePolicyID"] = _encode(_openapi_value.storagepolicyid)) + _openapi_value.storagepolicyname isa Absent || (_openapi_output["storagePolicyName"] = _encode(_openapi_value.storagepolicyname)) + _openapi_value.volumepath isa Absent || (_openapi_output["volumePath"] = _encode(_openapi_value.volumepath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.storagepolicyid isa Absent || push!(_openapi_output, "storagePolicyID" => _openapi_value.storagepolicyid) + _openapi_value.storagepolicyname isa Absent || push!(_openapi_output, "storagePolicyName" => _openapi_value.storagepolicyname) + _openapi_value.volumepath isa Absent || push!(_openapi_output, "volumePath" => _openapi_value.volumepath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeSpec + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + awselasticblockstore::Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing} = ABSENT + azuredisk::Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing} = ABSENT + azurefile::Union{Absent,IoK8sApiCoreV1AzureFilePersistentVolumeSource,Nothing} = ABSENT + capacity::Union{Absent,IoK8sApiCoreV1PersistentVolumeSpecCapacity,Nothing} = ABSENT + cephfs::Union{Absent,IoK8sApiCoreV1CephFSPersistentVolumeSource,Nothing} = ABSENT + cinder::Union{Absent,IoK8sApiCoreV1CinderPersistentVolumeSource,Nothing} = ABSENT + claimref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + csi::Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSource,Nothing} = ABSENT + fc::Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing} = ABSENT + flexvolume::Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSource,Nothing} = ABSENT + flocker::Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing} = ABSENT + gcepersistentdisk::Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing} = ABSENT + glusterfs::Union{Absent,IoK8sApiCoreV1GlusterfsPersistentVolumeSource,Nothing} = ABSENT + hostpath::Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing} = ABSENT + iscsi::Union{Absent,IoK8sApiCoreV1ISCSIPersistentVolumeSource,Nothing} = ABSENT + local_::Union{Absent,IoK8sApiCoreV1LocalVolumeSource,Nothing} = ABSENT + mountoptions::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + nfs::Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing} = ABSENT + nodeaffinity::Union{Absent,IoK8sApiCoreV1VolumeNodeAffinity,Nothing} = ABSENT + persistentvolumereclaimpolicy::Union{Absent,Nothing,String} = ABSENT + photonpersistentdisk::Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing} = ABSENT + portworxvolume::Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing} = ABSENT + quobyte::Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing} = ABSENT + rbd::Union{Absent,IoK8sApiCoreV1RBDPersistentVolumeSource,Nothing} = ABSENT + scaleio::Union{Absent,IoK8sApiCoreV1ScaleIOPersistentVolumeSource,Nothing} = ABSENT + storageclassname::Union{Absent,Nothing,String} = ABSENT + storageos::Union{Absent,IoK8sApiCoreV1StorageOSPersistentVolumeSource,Nothing} = ABSENT + volumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + volumemode::Union{Absent,Nothing,String} = ABSENT + vspherevolume::Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeSpec}, value) = _decode(IoK8sApiCoreV1PersistentVolumeSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeSpec") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_awselasticblockstore = haskey(_openapi_object, "awsElasticBlockStore") ? _decode(Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing}, _openapi_object["awsElasticBlockStore"], _openapi_validate) : ABSENT + _openapi_field_azuredisk = haskey(_openapi_object, "azureDisk") ? _decode(Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing}, _openapi_object["azureDisk"], _openapi_validate) : ABSENT + _openapi_field_azurefile = haskey(_openapi_object, "azureFile") ? _decode(Union{Absent,IoK8sApiCoreV1AzureFilePersistentVolumeSource,Nothing}, _openapi_object["azureFile"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeSpecCapacity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_cephfs = haskey(_openapi_object, "cephfs") ? _decode(Union{Absent,IoK8sApiCoreV1CephFSPersistentVolumeSource,Nothing}, _openapi_object["cephfs"], _openapi_validate) : ABSENT + _openapi_field_cinder = haskey(_openapi_object, "cinder") ? _decode(Union{Absent,IoK8sApiCoreV1CinderPersistentVolumeSource,Nothing}, _openapi_object["cinder"], _openapi_validate) : ABSENT + _openapi_field_claimref = haskey(_openapi_object, "claimRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["claimRef"], _openapi_validate) : ABSENT + _openapi_field_csi = haskey(_openapi_object, "csi") ? _decode(Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSource,Nothing}, _openapi_object["csi"], _openapi_validate) : ABSENT + _openapi_field_fc = haskey(_openapi_object, "fc") ? _decode(Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing}, _openapi_object["fc"], _openapi_validate) : ABSENT + _openapi_field_flexvolume = haskey(_openapi_object, "flexVolume") ? _decode(Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSource,Nothing}, _openapi_object["flexVolume"], _openapi_validate) : ABSENT + _openapi_field_flocker = haskey(_openapi_object, "flocker") ? _decode(Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing}, _openapi_object["flocker"], _openapi_validate) : ABSENT + _openapi_field_gcepersistentdisk = haskey(_openapi_object, "gcePersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing}, _openapi_object["gcePersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_glusterfs = haskey(_openapi_object, "glusterfs") ? _decode(Union{Absent,IoK8sApiCoreV1GlusterfsPersistentVolumeSource,Nothing}, _openapi_object["glusterfs"], _openapi_validate) : ABSENT + _openapi_field_hostpath = haskey(_openapi_object, "hostPath") ? _decode(Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing}, _openapi_object["hostPath"], _openapi_validate) : ABSENT + _openapi_field_iscsi = haskey(_openapi_object, "iscsi") ? _decode(Union{Absent,IoK8sApiCoreV1ISCSIPersistentVolumeSource,Nothing}, _openapi_object["iscsi"], _openapi_validate) : ABSENT + _openapi_field_local_ = haskey(_openapi_object, "local") ? _decode(Union{Absent,IoK8sApiCoreV1LocalVolumeSource,Nothing}, _openapi_object["local"], _openapi_validate) : ABSENT + _openapi_field_mountoptions = haskey(_openapi_object, "mountOptions") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mountOptions"], _openapi_validate) : ABSENT + _openapi_field_nfs = haskey(_openapi_object, "nfs") ? _decode(Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing}, _openapi_object["nfs"], _openapi_validate) : ABSENT + _openapi_field_nodeaffinity = haskey(_openapi_object, "nodeAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeNodeAffinity,Nothing}, _openapi_object["nodeAffinity"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumereclaimpolicy = haskey(_openapi_object, "persistentVolumeReclaimPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["persistentVolumeReclaimPolicy"], _openapi_validate) : ABSENT + _openapi_field_photonpersistentdisk = haskey(_openapi_object, "photonPersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing}, _openapi_object["photonPersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_portworxvolume = haskey(_openapi_object, "portworxVolume") ? _decode(Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing}, _openapi_object["portworxVolume"], _openapi_validate) : ABSENT + _openapi_field_quobyte = haskey(_openapi_object, "quobyte") ? _decode(Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing}, _openapi_object["quobyte"], _openapi_validate) : ABSENT + _openapi_field_rbd = haskey(_openapi_object, "rbd") ? _decode(Union{Absent,IoK8sApiCoreV1RBDPersistentVolumeSource,Nothing}, _openapi_object["rbd"], _openapi_validate) : ABSENT + _openapi_field_scaleio = haskey(_openapi_object, "scaleIO") ? _decode(Union{Absent,IoK8sApiCoreV1ScaleIOPersistentVolumeSource,Nothing}, _openapi_object["scaleIO"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = haskey(_openapi_object, "storageClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageClassName"], _openapi_validate) : ABSENT + _openapi_field_storageos = haskey(_openapi_object, "storageos") ? _decode(Union{Absent,IoK8sApiCoreV1StorageOSPersistentVolumeSource,Nothing}, _openapi_object["storageos"], _openapi_validate) : ABSENT + _openapi_field_volumeattributesclassname = haskey(_openapi_object, "volumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_volumemode = haskey(_openapi_object, "volumeMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeMode"], _openapi_validate) : ABSENT + _openapi_field_vspherevolume = haskey(_openapi_object, "vsphereVolume") ? _decode(Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing}, _openapi_object["vsphereVolume"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","awsElasticBlockStore","azureDisk","azureFile","capacity","cephfs","cinder","claimRef","csi","fc","flexVolume","flocker","gcePersistentDisk","glusterfs","hostPath","iscsi","local","mountOptions","nfs","nodeAffinity","persistentVolumeReclaimPolicy","photonPersistentDisk","portworxVolume","quobyte","rbd","scaleIO","storageClassName","storageos","volumeAttributesClassName","volumeMode","vsphereVolume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeSpec(; accessmodes = _openapi_field_accessmodes, awselasticblockstore = _openapi_field_awselasticblockstore, azuredisk = _openapi_field_azuredisk, azurefile = _openapi_field_azurefile, capacity = _openapi_field_capacity, cephfs = _openapi_field_cephfs, cinder = _openapi_field_cinder, claimref = _openapi_field_claimref, csi = _openapi_field_csi, fc = _openapi_field_fc, flexvolume = _openapi_field_flexvolume, flocker = _openapi_field_flocker, gcepersistentdisk = _openapi_field_gcepersistentdisk, glusterfs = _openapi_field_glusterfs, hostpath = _openapi_field_hostpath, iscsi = _openapi_field_iscsi, local_ = _openapi_field_local_, mountoptions = _openapi_field_mountoptions, nfs = _openapi_field_nfs, nodeaffinity = _openapi_field_nodeaffinity, persistentvolumereclaimpolicy = _openapi_field_persistentvolumereclaimpolicy, photonpersistentdisk = _openapi_field_photonpersistentdisk, portworxvolume = _openapi_field_portworxvolume, quobyte = _openapi_field_quobyte, rbd = _openapi_field_rbd, scaleio = _openapi_field_scaleio, storageclassname = _openapi_field_storageclassname, storageos = _openapi_field_storageos, volumeattributesclassname = _openapi_field_volumeattributesclassname, volumemode = _openapi_field_volumemode, vspherevolume = _openapi_field_vspherevolume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.awselasticblockstore isa Absent || (_openapi_output["awsElasticBlockStore"] = _encode(_openapi_value.awselasticblockstore)) + _openapi_value.azuredisk isa Absent || (_openapi_output["azureDisk"] = _encode(_openapi_value.azuredisk)) + _openapi_value.azurefile isa Absent || (_openapi_output["azureFile"] = _encode(_openapi_value.azurefile)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.cephfs isa Absent || (_openapi_output["cephfs"] = _encode(_openapi_value.cephfs)) + _openapi_value.cinder isa Absent || (_openapi_output["cinder"] = _encode(_openapi_value.cinder)) + _openapi_value.claimref isa Absent || (_openapi_output["claimRef"] = _encode(_openapi_value.claimref)) + _openapi_value.csi isa Absent || (_openapi_output["csi"] = _encode(_openapi_value.csi)) + _openapi_value.fc isa Absent || (_openapi_output["fc"] = _encode(_openapi_value.fc)) + _openapi_value.flexvolume isa Absent || (_openapi_output["flexVolume"] = _encode(_openapi_value.flexvolume)) + _openapi_value.flocker isa Absent || (_openapi_output["flocker"] = _encode(_openapi_value.flocker)) + _openapi_value.gcepersistentdisk isa Absent || (_openapi_output["gcePersistentDisk"] = _encode(_openapi_value.gcepersistentdisk)) + _openapi_value.glusterfs isa Absent || (_openapi_output["glusterfs"] = _encode(_openapi_value.glusterfs)) + _openapi_value.hostpath isa Absent || (_openapi_output["hostPath"] = _encode(_openapi_value.hostpath)) + _openapi_value.iscsi isa Absent || (_openapi_output["iscsi"] = _encode(_openapi_value.iscsi)) + _openapi_value.local_ isa Absent || (_openapi_output["local"] = _encode(_openapi_value.local_)) + _openapi_value.mountoptions isa Absent || (_openapi_output["mountOptions"] = _encode(_openapi_value.mountoptions)) + _openapi_value.nfs isa Absent || (_openapi_output["nfs"] = _encode(_openapi_value.nfs)) + _openapi_value.nodeaffinity isa Absent || (_openapi_output["nodeAffinity"] = _encode(_openapi_value.nodeaffinity)) + _openapi_value.persistentvolumereclaimpolicy isa Absent || (_openapi_output["persistentVolumeReclaimPolicy"] = _encode(_openapi_value.persistentvolumereclaimpolicy)) + _openapi_value.photonpersistentdisk isa Absent || (_openapi_output["photonPersistentDisk"] = _encode(_openapi_value.photonpersistentdisk)) + _openapi_value.portworxvolume isa Absent || (_openapi_output["portworxVolume"] = _encode(_openapi_value.portworxvolume)) + _openapi_value.quobyte isa Absent || (_openapi_output["quobyte"] = _encode(_openapi_value.quobyte)) + _openapi_value.rbd isa Absent || (_openapi_output["rbd"] = _encode(_openapi_value.rbd)) + _openapi_value.scaleio isa Absent || (_openapi_output["scaleIO"] = _encode(_openapi_value.scaleio)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + _openapi_value.storageos isa Absent || (_openapi_output["storageos"] = _encode(_openapi_value.storageos)) + _openapi_value.volumeattributesclassname isa Absent || (_openapi_output["volumeAttributesClassName"] = _encode(_openapi_value.volumeattributesclassname)) + _openapi_value.volumemode isa Absent || (_openapi_output["volumeMode"] = _encode(_openapi_value.volumemode)) + _openapi_value.vspherevolume isa Absent || (_openapi_output["vsphereVolume"] = _encode(_openapi_value.vspherevolume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.awselasticblockstore isa Absent || push!(_openapi_output, "awsElasticBlockStore" => _openapi_value.awselasticblockstore) + _openapi_value.azuredisk isa Absent || push!(_openapi_output, "azureDisk" => _openapi_value.azuredisk) + _openapi_value.azurefile isa Absent || push!(_openapi_output, "azureFile" => _openapi_value.azurefile) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.cephfs isa Absent || push!(_openapi_output, "cephfs" => _openapi_value.cephfs) + _openapi_value.cinder isa Absent || push!(_openapi_output, "cinder" => _openapi_value.cinder) + _openapi_value.claimref isa Absent || push!(_openapi_output, "claimRef" => _openapi_value.claimref) + _openapi_value.csi isa Absent || push!(_openapi_output, "csi" => _openapi_value.csi) + _openapi_value.fc isa Absent || push!(_openapi_output, "fc" => _openapi_value.fc) + _openapi_value.flexvolume isa Absent || push!(_openapi_output, "flexVolume" => _openapi_value.flexvolume) + _openapi_value.flocker isa Absent || push!(_openapi_output, "flocker" => _openapi_value.flocker) + _openapi_value.gcepersistentdisk isa Absent || push!(_openapi_output, "gcePersistentDisk" => _openapi_value.gcepersistentdisk) + _openapi_value.glusterfs isa Absent || push!(_openapi_output, "glusterfs" => _openapi_value.glusterfs) + _openapi_value.hostpath isa Absent || push!(_openapi_output, "hostPath" => _openapi_value.hostpath) + _openapi_value.iscsi isa Absent || push!(_openapi_output, "iscsi" => _openapi_value.iscsi) + _openapi_value.local_ isa Absent || push!(_openapi_output, "local" => _openapi_value.local_) + _openapi_value.mountoptions isa Absent || push!(_openapi_output, "mountOptions" => _openapi_value.mountoptions) + _openapi_value.nfs isa Absent || push!(_openapi_output, "nfs" => _openapi_value.nfs) + _openapi_value.nodeaffinity isa Absent || push!(_openapi_output, "nodeAffinity" => _openapi_value.nodeaffinity) + _openapi_value.persistentvolumereclaimpolicy isa Absent || push!(_openapi_output, "persistentVolumeReclaimPolicy" => _openapi_value.persistentvolumereclaimpolicy) + _openapi_value.photonpersistentdisk isa Absent || push!(_openapi_output, "photonPersistentDisk" => _openapi_value.photonpersistentdisk) + _openapi_value.portworxvolume isa Absent || push!(_openapi_output, "portworxVolume" => _openapi_value.portworxvolume) + _openapi_value.quobyte isa Absent || push!(_openapi_output, "quobyte" => _openapi_value.quobyte) + _openapi_value.rbd isa Absent || push!(_openapi_output, "rbd" => _openapi_value.rbd) + _openapi_value.scaleio isa Absent || push!(_openapi_output, "scaleIO" => _openapi_value.scaleio) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + _openapi_value.storageos isa Absent || push!(_openapi_output, "storageos" => _openapi_value.storageos) + _openapi_value.volumeattributesclassname isa Absent || push!(_openapi_output, "volumeAttributesClassName" => _openapi_value.volumeattributesclassname) + _openapi_value.volumemode isa Absent || push!(_openapi_output, "volumeMode" => _openapi_value.volumemode) + _openapi_value.vspherevolume isa Absent || push!(_openapi_output, "vsphereVolume" => _openapi_value.vspherevolume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TopologySelectorLabelRequirement + key::String + values::Union{Nothing,Vector{String}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TopologySelectorLabelRequirement}, value) = _decode(IoK8sApiCoreV1TopologySelectorLabelRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1TopologySelectorLabelRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1TopologySelectorLabelRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TopologySelectorLabelRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1TopologySelectorLabelRequirement"), _openapi_validate) + _openapi_field_values = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "values", "IoK8sApiCoreV1TopologySelectorLabelRequirement"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TopologySelectorLabelRequirement(; key = _openapi_field_key, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TopologySelectorLabelRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorLabelRequirement"), _openapi_output, "encoding IoK8sApiCoreV1TopologySelectorLabelRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TopologySelectorLabelRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TopologySelectorTerm + matchlabelexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySelectorLabelRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TopologySelectorTerm}, value) = _decode(IoK8sApiCoreV1TopologySelectorTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1TopologySelectorTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm"), _openapi_raw, "decoding IoK8sApiCoreV1TopologySelectorTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TopologySelectorTerm") + _openapi_field_matchlabelexpressions = haskey(_openapi_object, "matchLabelExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySelectorLabelRequirement}}}, _openapi_object["matchLabelExpressions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchLabelExpressions",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TopologySelectorTerm(; matchlabelexpressions = _openapi_field_matchlabelexpressions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TopologySelectorTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchlabelexpressions isa Absent || (_openapi_output["matchLabelExpressions"] = _encode(_openapi_value.matchlabelexpressions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySelectorTerm"), _openapi_output, "encoding IoK8sApiCoreV1TopologySelectorTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TopologySelectorTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchlabelexpressions isa Absent || push!(_openapi_output, "matchLabelExpressions" => _openapi_value.matchlabelexpressions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1TokenRequest + audience::String + expirationseconds::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1TokenRequest}, value) = _decode(IoK8sApiStorageV1TokenRequest, value, true) +function _decode(::Type{IoK8sApiStorageV1TokenRequest}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.TokenRequest"), _openapi_raw, "decoding IoK8sApiStorageV1TokenRequest"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1TokenRequest") + _openapi_field_audience = _decode(String, _required(_openapi_object, "audience", "IoK8sApiStorageV1TokenRequest"), _openapi_validate) + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("audience","expirationSeconds") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1TokenRequest(; audience = _openapi_field_audience, expirationseconds = _openapi_field_expirationseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1TokenRequest) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.audience isa Absent || (_openapi_output["audience"] = _encode(_openapi_value.audience)) + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.TokenRequest"), _openapi_output, "encoding IoK8sApiStorageV1TokenRequest"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1TokenRequest) + _openapi_output = Pair{String,Any}[] + _openapi_value.audience isa Absent || push!(_openapi_output, "audience" => _openapi_value.audience) + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSIDriverSpec + attachrequired::Union{Absent,Bool,Nothing} = ABSENT + fsgrouppolicy::Union{Absent,Nothing,String} = ABSENT + nodeallocatableupdateperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + podinfoonmount::Union{Absent,Bool,Nothing} = ABSENT + requiresrepublish::Union{Absent,Bool,Nothing} = ABSENT + selinuxmount::Union{Absent,Bool,Nothing} = ABSENT + serviceaccounttokeninsecrets::Union{Absent,Bool,Nothing} = ABSENT + storagecapacity::Union{Absent,Bool,Nothing} = ABSENT + tokenrequests::Union{Absent,Union{Nothing,Vector{IoK8sApiStorageV1TokenRequest}}} = ABSENT + volumelifecyclemodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSIDriverSpec}, value) = _decode(IoK8sApiStorageV1CSIDriverSpec, value, true) +function _decode(::Type{IoK8sApiStorageV1CSIDriverSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec"), _openapi_raw, "decoding IoK8sApiStorageV1CSIDriverSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSIDriverSpec") + _openapi_field_attachrequired = haskey(_openapi_object, "attachRequired") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["attachRequired"], _openapi_validate) : ABSENT + _openapi_field_fsgrouppolicy = haskey(_openapi_object, "fsGroupPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsGroupPolicy"], _openapi_validate) : ABSENT + _openapi_field_nodeallocatableupdateperiodseconds = haskey(_openapi_object, "nodeAllocatableUpdatePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["nodeAllocatableUpdatePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_podinfoonmount = haskey(_openapi_object, "podInfoOnMount") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["podInfoOnMount"], _openapi_validate) : ABSENT + _openapi_field_requiresrepublish = haskey(_openapi_object, "requiresRepublish") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["requiresRepublish"], _openapi_validate) : ABSENT + _openapi_field_selinuxmount = haskey(_openapi_object, "seLinuxMount") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["seLinuxMount"], _openapi_validate) : ABSENT + _openapi_field_serviceaccounttokeninsecrets = haskey(_openapi_object, "serviceAccountTokenInSecrets") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["serviceAccountTokenInSecrets"], _openapi_validate) : ABSENT + _openapi_field_storagecapacity = haskey(_openapi_object, "storageCapacity") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["storageCapacity"], _openapi_validate) : ABSENT + _openapi_field_tokenrequests = haskey(_openapi_object, "tokenRequests") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiStorageV1TokenRequest}}}, _openapi_object["tokenRequests"], _openapi_validate) : ABSENT + _openapi_field_volumelifecyclemodes = haskey(_openapi_object, "volumeLifecycleModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["volumeLifecycleModes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("attachRequired","fsGroupPolicy","nodeAllocatableUpdatePeriodSeconds","podInfoOnMount","requiresRepublish","seLinuxMount","serviceAccountTokenInSecrets","storageCapacity","tokenRequests","volumeLifecycleModes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSIDriverSpec(; attachrequired = _openapi_field_attachrequired, fsgrouppolicy = _openapi_field_fsgrouppolicy, nodeallocatableupdateperiodseconds = _openapi_field_nodeallocatableupdateperiodseconds, podinfoonmount = _openapi_field_podinfoonmount, requiresrepublish = _openapi_field_requiresrepublish, selinuxmount = _openapi_field_selinuxmount, serviceaccounttokeninsecrets = _openapi_field_serviceaccounttokeninsecrets, storagecapacity = _openapi_field_storagecapacity, tokenrequests = _openapi_field_tokenrequests, volumelifecyclemodes = _openapi_field_volumelifecyclemodes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSIDriverSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.attachrequired isa Absent || (_openapi_output["attachRequired"] = _encode(_openapi_value.attachrequired)) + _openapi_value.fsgrouppolicy isa Absent || (_openapi_output["fsGroupPolicy"] = _encode(_openapi_value.fsgrouppolicy)) + _openapi_value.nodeallocatableupdateperiodseconds isa Absent || (_openapi_output["nodeAllocatableUpdatePeriodSeconds"] = _encode(_openapi_value.nodeallocatableupdateperiodseconds)) + _openapi_value.podinfoonmount isa Absent || (_openapi_output["podInfoOnMount"] = _encode(_openapi_value.podinfoonmount)) + _openapi_value.requiresrepublish isa Absent || (_openapi_output["requiresRepublish"] = _encode(_openapi_value.requiresrepublish)) + _openapi_value.selinuxmount isa Absent || (_openapi_output["seLinuxMount"] = _encode(_openapi_value.selinuxmount)) + _openapi_value.serviceaccounttokeninsecrets isa Absent || (_openapi_output["serviceAccountTokenInSecrets"] = _encode(_openapi_value.serviceaccounttokeninsecrets)) + _openapi_value.storagecapacity isa Absent || (_openapi_output["storageCapacity"] = _encode(_openapi_value.storagecapacity)) + _openapi_value.tokenrequests isa Absent || (_openapi_output["tokenRequests"] = _encode(_openapi_value.tokenrequests)) + _openapi_value.volumelifecyclemodes isa Absent || (_openapi_output["volumeLifecycleModes"] = _encode(_openapi_value.volumelifecyclemodes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverSpec"), _openapi_output, "encoding IoK8sApiStorageV1CSIDriverSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSIDriverSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.attachrequired isa Absent || push!(_openapi_output, "attachRequired" => _openapi_value.attachrequired) + _openapi_value.fsgrouppolicy isa Absent || push!(_openapi_output, "fsGroupPolicy" => _openapi_value.fsgrouppolicy) + _openapi_value.nodeallocatableupdateperiodseconds isa Absent || push!(_openapi_output, "nodeAllocatableUpdatePeriodSeconds" => _openapi_value.nodeallocatableupdateperiodseconds) + _openapi_value.podinfoonmount isa Absent || push!(_openapi_output, "podInfoOnMount" => _openapi_value.podinfoonmount) + _openapi_value.requiresrepublish isa Absent || push!(_openapi_output, "requiresRepublish" => _openapi_value.requiresrepublish) + _openapi_value.selinuxmount isa Absent || push!(_openapi_output, "seLinuxMount" => _openapi_value.selinuxmount) + _openapi_value.serviceaccounttokeninsecrets isa Absent || push!(_openapi_output, "serviceAccountTokenInSecrets" => _openapi_value.serviceaccounttokeninsecrets) + _openapi_value.storagecapacity isa Absent || push!(_openapi_output, "storageCapacity" => _openapi_value.storagecapacity) + _openapi_value.tokenrequests isa Absent || push!(_openapi_output, "tokenRequests" => _openapi_value.tokenrequests) + _openapi_value.volumelifecyclemodes isa Absent || push!(_openapi_output, "volumeLifecycleModes" => _openapi_value.volumelifecyclemodes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSIDriver + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiStorageV1CSIDriverSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSIDriver}, value) = _decode(IoK8sApiStorageV1CSIDriver, value, true) +function _decode(::Type{IoK8sApiStorageV1CSIDriver}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriver"), _openapi_raw, "decoding IoK8sApiStorageV1CSIDriver"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSIDriver") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiStorageV1CSIDriverSpec, _required(_openapi_object, "spec", "IoK8sApiStorageV1CSIDriver"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSIDriver(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSIDriver) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriver"), _openapi_output, "encoding IoK8sApiStorageV1CSIDriver"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSIDriver) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSIDriverList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1CSIDriver}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSIDriverList}, value) = _decode(IoK8sApiStorageV1CSIDriverList, value, true) +function _decode(::Type{IoK8sApiStorageV1CSIDriverList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverList"), _openapi_raw, "decoding IoK8sApiStorageV1CSIDriverList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSIDriverList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1CSIDriver}}, _required(_openapi_object, "items", "IoK8sApiStorageV1CSIDriverList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSIDriverList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSIDriverList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIDriverList"), _openapi_output, "encoding IoK8sApiStorageV1CSIDriverList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSIDriverList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeNodeResources + count::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeNodeResources}, value) = _decode(IoK8sApiStorageV1VolumeNodeResources, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeNodeResources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeNodeResources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeNodeResources") + _openapi_field_count = haskey(_openapi_object, "count") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["count"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("count",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeNodeResources(; count = _openapi_field_count, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeNodeResources) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.count isa Absent || (_openapi_output["count"] = _encode(_openapi_value.count)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeNodeResources"), _openapi_output, "encoding IoK8sApiStorageV1VolumeNodeResources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeNodeResources) + _openapi_output = Pair{String,Any}[] + _openapi_value.count isa Absent || push!(_openapi_output, "count" => _openapi_value.count) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSINodeDriver + allocatable::Union{Absent,IoK8sApiStorageV1VolumeNodeResources,Nothing} = ABSENT + name::String + nodeid::String + topologykeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSINodeDriver}, value) = _decode(IoK8sApiStorageV1CSINodeDriver, value, true) +function _decode(::Type{IoK8sApiStorageV1CSINodeDriver}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeDriver"), _openapi_raw, "decoding IoK8sApiStorageV1CSINodeDriver"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSINodeDriver") + _openapi_field_allocatable = haskey(_openapi_object, "allocatable") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeNodeResources,Nothing}, _openapi_object["allocatable"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiStorageV1CSINodeDriver"), _openapi_validate) + _openapi_field_nodeid = _decode(String, _required(_openapi_object, "nodeID", "IoK8sApiStorageV1CSINodeDriver"), _openapi_validate) + _openapi_field_topologykeys = haskey(_openapi_object, "topologyKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["topologyKeys"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allocatable","name","nodeID","topologyKeys") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSINodeDriver(; allocatable = _openapi_field_allocatable, name = _openapi_field_name, nodeid = _openapi_field_nodeid, topologykeys = _openapi_field_topologykeys, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSINodeDriver) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allocatable isa Absent || (_openapi_output["allocatable"] = _encode(_openapi_value.allocatable)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.nodeid isa Absent || (_openapi_output["nodeID"] = _encode(_openapi_value.nodeid)) + _openapi_value.topologykeys isa Absent || (_openapi_output["topologyKeys"] = _encode(_openapi_value.topologykeys)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeDriver"), _openapi_output, "encoding IoK8sApiStorageV1CSINodeDriver"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSINodeDriver) + _openapi_output = Pair{String,Any}[] + _openapi_value.allocatable isa Absent || push!(_openapi_output, "allocatable" => _openapi_value.allocatable) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.nodeid isa Absent || push!(_openapi_output, "nodeID" => _openapi_value.nodeid) + _openapi_value.topologykeys isa Absent || push!(_openapi_output, "topologyKeys" => _openapi_value.topologykeys) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSINodeSpec + drivers::Union{Nothing,Vector{IoK8sApiStorageV1CSINodeDriver}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSINodeSpec}, value) = _decode(IoK8sApiStorageV1CSINodeSpec, value, true) +function _decode(::Type{IoK8sApiStorageV1CSINodeSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeSpec"), _openapi_raw, "decoding IoK8sApiStorageV1CSINodeSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSINodeSpec") + _openapi_field_drivers = _decode(Union{Nothing,Vector{IoK8sApiStorageV1CSINodeDriver}}, _required(_openapi_object, "drivers", "IoK8sApiStorageV1CSINodeSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("drivers",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSINodeSpec(; drivers = _openapi_field_drivers, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSINodeSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.drivers isa Absent || (_openapi_output["drivers"] = _encode(_openapi_value.drivers)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeSpec"), _openapi_output, "encoding IoK8sApiStorageV1CSINodeSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSINodeSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.drivers isa Absent || push!(_openapi_output, "drivers" => _openapi_value.drivers) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSINode + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiStorageV1CSINodeSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSINode}, value) = _decode(IoK8sApiStorageV1CSINode, value, true) +function _decode(::Type{IoK8sApiStorageV1CSINode}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINode"), _openapi_raw, "decoding IoK8sApiStorageV1CSINode"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSINode") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiStorageV1CSINodeSpec, _required(_openapi_object, "spec", "IoK8sApiStorageV1CSINode"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSINode(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSINode) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINode"), _openapi_output, "encoding IoK8sApiStorageV1CSINode"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSINode) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSINodeList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1CSINode}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSINodeList}, value) = _decode(IoK8sApiStorageV1CSINodeList, value, true) +function _decode(::Type{IoK8sApiStorageV1CSINodeList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeList"), _openapi_raw, "decoding IoK8sApiStorageV1CSINodeList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSINodeList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1CSINode}}, _required(_openapi_object, "items", "IoK8sApiStorageV1CSINodeList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSINodeList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSINodeList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSINodeList"), _openapi_output, "encoding IoK8sApiStorageV1CSINodeList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSINodeList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSIStorageCapacity + apiversion::Union{Absent,Nothing,String} = ABSENT + capacity::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + maximumvolumesize::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + nodetopology::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + storageclassname::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSIStorageCapacity}, value) = _decode(IoK8sApiStorageV1CSIStorageCapacity, value, true) +function _decode(::Type{IoK8sApiStorageV1CSIStorageCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity"), _openapi_raw, "decoding IoK8sApiStorageV1CSIStorageCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSIStorageCapacity") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_maximumvolumesize = haskey(_openapi_object, "maximumVolumeSize") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["maximumVolumeSize"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_nodetopology = haskey(_openapi_object, "nodeTopology") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["nodeTopology"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = _decode(String, _required(_openapi_object, "storageClassName", "IoK8sApiStorageV1CSIStorageCapacity"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","capacity","kind","maximumVolumeSize","metadata","nodeTopology","storageClassName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSIStorageCapacity(; apiversion = _openapi_field_apiversion, capacity = _openapi_field_capacity, kind = _openapi_field_kind, maximumvolumesize = _openapi_field_maximumvolumesize, metadata = _openapi_field_metadata, nodetopology = _openapi_field_nodetopology, storageclassname = _openapi_field_storageclassname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSIStorageCapacity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.maximumvolumesize isa Absent || (_openapi_output["maximumVolumeSize"] = _encode(_openapi_value.maximumvolumesize)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.nodetopology isa Absent || (_openapi_output["nodeTopology"] = _encode(_openapi_value.nodetopology)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacity"), _openapi_output, "encoding IoK8sApiStorageV1CSIStorageCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSIStorageCapacity) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.maximumvolumesize isa Absent || push!(_openapi_output, "maximumVolumeSize" => _openapi_value.maximumvolumesize) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.nodetopology isa Absent || push!(_openapi_output, "nodeTopology" => _openapi_value.nodetopology) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1CSIStorageCapacityList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1CSIStorageCapacity}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1CSIStorageCapacityList}, value) = _decode(IoK8sApiStorageV1CSIStorageCapacityList, value, true) +function _decode(::Type{IoK8sApiStorageV1CSIStorageCapacityList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList"), _openapi_raw, "decoding IoK8sApiStorageV1CSIStorageCapacityList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1CSIStorageCapacityList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1CSIStorageCapacity}}, _required(_openapi_object, "items", "IoK8sApiStorageV1CSIStorageCapacityList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1CSIStorageCapacityList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1CSIStorageCapacityList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.CSIStorageCapacityList"), _openapi_output, "encoding IoK8sApiStorageV1CSIStorageCapacityList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1CSIStorageCapacityList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1StorageClassParameters + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiStorageV1StorageClassParameters}, value) = _decode(IoK8sApiStorageV1StorageClassParameters, value, true) +function _decode(::Type{IoK8sApiStorageV1StorageClassParameters}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClass/properties/parameters"), _openapi_raw, "decoding IoK8sApiStorageV1StorageClassParameters"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1StorageClassParameters") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1StorageClassParameters(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1StorageClassParameters) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClass/properties/parameters"), _openapi_output, "encoding IoK8sApiStorageV1StorageClassParameters"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1StorageClassParameters) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1StorageClass + allowvolumeexpansion::Union{Absent,Bool,Nothing} = ABSENT + allowedtopologies::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySelectorTerm}}} = ABSENT + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + mountoptions::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + parameters::Union{Absent,IoK8sApiStorageV1StorageClassParameters,Nothing} = ABSENT + provisioner::String + reclaimpolicy::Union{Absent,Nothing,String} = ABSENT + volumebindingmode::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1StorageClass}, value) = _decode(IoK8sApiStorageV1StorageClass, value, true) +function _decode(::Type{IoK8sApiStorageV1StorageClass}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClass"), _openapi_raw, "decoding IoK8sApiStorageV1StorageClass"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1StorageClass") + _openapi_field_allowvolumeexpansion = haskey(_openapi_object, "allowVolumeExpansion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["allowVolumeExpansion"], _openapi_validate) : ABSENT + _openapi_field_allowedtopologies = haskey(_openapi_object, "allowedTopologies") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySelectorTerm}}}, _openapi_object["allowedTopologies"], _openapi_validate) : ABSENT + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_mountoptions = haskey(_openapi_object, "mountOptions") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mountOptions"], _openapi_validate) : ABSENT + _openapi_field_parameters = haskey(_openapi_object, "parameters") ? _decode(Union{Absent,IoK8sApiStorageV1StorageClassParameters,Nothing}, _openapi_object["parameters"], _openapi_validate) : ABSENT + _openapi_field_provisioner = _decode(String, _required(_openapi_object, "provisioner", "IoK8sApiStorageV1StorageClass"), _openapi_validate) + _openapi_field_reclaimpolicy = haskey(_openapi_object, "reclaimPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reclaimPolicy"], _openapi_validate) : ABSENT + _openapi_field_volumebindingmode = haskey(_openapi_object, "volumeBindingMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeBindingMode"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allowVolumeExpansion","allowedTopologies","apiVersion","kind","metadata","mountOptions","parameters","provisioner","reclaimPolicy","volumeBindingMode") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1StorageClass(; allowvolumeexpansion = _openapi_field_allowvolumeexpansion, allowedtopologies = _openapi_field_allowedtopologies, apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, mountoptions = _openapi_field_mountoptions, parameters = _openapi_field_parameters, provisioner = _openapi_field_provisioner, reclaimpolicy = _openapi_field_reclaimpolicy, volumebindingmode = _openapi_field_volumebindingmode, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1StorageClass) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allowvolumeexpansion isa Absent || (_openapi_output["allowVolumeExpansion"] = _encode(_openapi_value.allowvolumeexpansion)) + _openapi_value.allowedtopologies isa Absent || (_openapi_output["allowedTopologies"] = _encode(_openapi_value.allowedtopologies)) + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.mountoptions isa Absent || (_openapi_output["mountOptions"] = _encode(_openapi_value.mountoptions)) + _openapi_value.parameters isa Absent || (_openapi_output["parameters"] = _encode(_openapi_value.parameters)) + _openapi_value.provisioner isa Absent || (_openapi_output["provisioner"] = _encode(_openapi_value.provisioner)) + _openapi_value.reclaimpolicy isa Absent || (_openapi_output["reclaimPolicy"] = _encode(_openapi_value.reclaimpolicy)) + _openapi_value.volumebindingmode isa Absent || (_openapi_output["volumeBindingMode"] = _encode(_openapi_value.volumebindingmode)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClass"), _openapi_output, "encoding IoK8sApiStorageV1StorageClass"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1StorageClass) + _openapi_output = Pair{String,Any}[] + _openapi_value.allowvolumeexpansion isa Absent || push!(_openapi_output, "allowVolumeExpansion" => _openapi_value.allowvolumeexpansion) + _openapi_value.allowedtopologies isa Absent || push!(_openapi_output, "allowedTopologies" => _openapi_value.allowedtopologies) + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.mountoptions isa Absent || push!(_openapi_output, "mountOptions" => _openapi_value.mountoptions) + _openapi_value.parameters isa Absent || push!(_openapi_output, "parameters" => _openapi_value.parameters) + _openapi_value.provisioner isa Absent || push!(_openapi_output, "provisioner" => _openapi_value.provisioner) + _openapi_value.reclaimpolicy isa Absent || push!(_openapi_output, "reclaimPolicy" => _openapi_value.reclaimpolicy) + _openapi_value.volumebindingmode isa Absent || push!(_openapi_output, "volumeBindingMode" => _openapi_value.volumebindingmode) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1StorageClassList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1StorageClass}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1StorageClassList}, value) = _decode(IoK8sApiStorageV1StorageClassList, value, true) +function _decode(::Type{IoK8sApiStorageV1StorageClassList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClassList"), _openapi_raw, "decoding IoK8sApiStorageV1StorageClassList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1StorageClassList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1StorageClass}}, _required(_openapi_object, "items", "IoK8sApiStorageV1StorageClassList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1StorageClassList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1StorageClassList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.StorageClassList"), _openapi_output, "encoding IoK8sApiStorageV1StorageClassList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1StorageClassList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachmentSource + inlinevolumespec::Union{Absent,IoK8sApiCoreV1PersistentVolumeSpec,Nothing} = ABSENT + persistentvolumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachmentSource}, value) = _decode(IoK8sApiStorageV1VolumeAttachmentSource, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachmentSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachmentSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachmentSource") + _openapi_field_inlinevolumespec = haskey(_openapi_object, "inlineVolumeSpec") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeSpec,Nothing}, _openapi_object["inlineVolumeSpec"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumename = haskey(_openapi_object, "persistentVolumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["persistentVolumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("inlineVolumeSpec","persistentVolumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachmentSource(; inlinevolumespec = _openapi_field_inlinevolumespec, persistentvolumename = _openapi_field_persistentvolumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachmentSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.inlinevolumespec isa Absent || (_openapi_output["inlineVolumeSpec"] = _encode(_openapi_value.inlinevolumespec)) + _openapi_value.persistentvolumename isa Absent || (_openapi_output["persistentVolumeName"] = _encode(_openapi_value.persistentvolumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSource"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachmentSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachmentSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.inlinevolumespec isa Absent || push!(_openapi_output, "inlineVolumeSpec" => _openapi_value.inlinevolumespec) + _openapi_value.persistentvolumename isa Absent || push!(_openapi_output, "persistentVolumeName" => _openapi_value.persistentvolumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachmentSpec + attacher::String + nodename::String + source::IoK8sApiStorageV1VolumeAttachmentSource + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachmentSpec}, value) = _decode(IoK8sApiStorageV1VolumeAttachmentSpec, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachmentSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachmentSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachmentSpec") + _openapi_field_attacher = _decode(String, _required(_openapi_object, "attacher", "IoK8sApiStorageV1VolumeAttachmentSpec"), _openapi_validate) + _openapi_field_nodename = _decode(String, _required(_openapi_object, "nodeName", "IoK8sApiStorageV1VolumeAttachmentSpec"), _openapi_validate) + _openapi_field_source = _decode(IoK8sApiStorageV1VolumeAttachmentSource, _required(_openapi_object, "source", "IoK8sApiStorageV1VolumeAttachmentSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("attacher","nodeName","source") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachmentSpec(; attacher = _openapi_field_attacher, nodename = _openapi_field_nodename, source = _openapi_field_source, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachmentSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.attacher isa Absent || (_openapi_output["attacher"] = _encode(_openapi_value.attacher)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.source isa Absent || (_openapi_output["source"] = _encode(_openapi_value.source)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentSpec"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachmentSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachmentSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.attacher isa Absent || push!(_openapi_output, "attacher" => _openapi_value.attacher) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.source isa Absent || push!(_openapi_output, "source" => _openapi_value.source) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeError + errorcode::Union{Absent,Int32,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeError}, value) = _decode(IoK8sApiStorageV1VolumeError, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeError}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeError"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeError"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeError") + _openapi_field_errorcode = haskey(_openapi_object, "errorCode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["errorCode"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("errorCode","message","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeError(; errorcode = _openapi_field_errorcode, message = _openapi_field_message, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeError) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.errorcode isa Absent || (_openapi_output["errorCode"] = _encode(_openapi_value.errorcode)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeError"), _openapi_output, "encoding IoK8sApiStorageV1VolumeError"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeError) + _openapi_output = Pair{String,Any}[] + _openapi_value.errorcode isa Absent || push!(_openapi_output, "errorCode" => _openapi_value.errorcode) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata}, value) = _decode(IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus/properties/attachmentMetadata"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus/properties/attachmentMetadata"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachmentStatus + attacherror::Union{Absent,IoK8sApiStorageV1VolumeError,Nothing} = ABSENT + attached::Bool + attachmentmetadata::Union{Absent,IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata,Nothing} = ABSENT + detacherror::Union{Absent,IoK8sApiStorageV1VolumeError,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachmentStatus}, value) = _decode(IoK8sApiStorageV1VolumeAttachmentStatus, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachmentStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachmentStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachmentStatus") + _openapi_field_attacherror = haskey(_openapi_object, "attachError") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeError,Nothing}, _openapi_object["attachError"], _openapi_validate) : ABSENT + _openapi_field_attached = _decode(Bool, _required(_openapi_object, "attached", "IoK8sApiStorageV1VolumeAttachmentStatus"), _openapi_validate) + _openapi_field_attachmentmetadata = haskey(_openapi_object, "attachmentMetadata") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeAttachmentStatusAttachmentMetadata,Nothing}, _openapi_object["attachmentMetadata"], _openapi_validate) : ABSENT + _openapi_field_detacherror = haskey(_openapi_object, "detachError") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeError,Nothing}, _openapi_object["detachError"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("attachError","attached","attachmentMetadata","detachError") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachmentStatus(; attacherror = _openapi_field_attacherror, attached = _openapi_field_attached, attachmentmetadata = _openapi_field_attachmentmetadata, detacherror = _openapi_field_detacherror, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachmentStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.attacherror isa Absent || (_openapi_output["attachError"] = _encode(_openapi_value.attacherror)) + _openapi_value.attached isa Absent || (_openapi_output["attached"] = _encode(_openapi_value.attached)) + _openapi_value.attachmentmetadata isa Absent || (_openapi_output["attachmentMetadata"] = _encode(_openapi_value.attachmentmetadata)) + _openapi_value.detacherror isa Absent || (_openapi_output["detachError"] = _encode(_openapi_value.detacherror)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentStatus"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachmentStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachmentStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.attacherror isa Absent || push!(_openapi_output, "attachError" => _openapi_value.attacherror) + _openapi_value.attached isa Absent || push!(_openapi_output, "attached" => _openapi_value.attached) + _openapi_value.attachmentmetadata isa Absent || push!(_openapi_output, "attachmentMetadata" => _openapi_value.attachmentmetadata) + _openapi_value.detacherror isa Absent || push!(_openapi_output, "detachError" => _openapi_value.detacherror) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachment + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiStorageV1VolumeAttachmentSpec + status::Union{Absent,IoK8sApiStorageV1VolumeAttachmentStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachment}, value) = _decode(IoK8sApiStorageV1VolumeAttachment, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachment}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachment"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachment"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachment") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiStorageV1VolumeAttachmentSpec, _required(_openapi_object, "spec", "IoK8sApiStorageV1VolumeAttachment"), _openapi_validate) + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeAttachmentStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachment(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachment) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachment"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachment"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachment) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttachmentList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1VolumeAttachment}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttachmentList}, value) = _decode(IoK8sApiStorageV1VolumeAttachmentList, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttachmentList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttachmentList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttachmentList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1VolumeAttachment}}, _required(_openapi_object, "items", "IoK8sApiStorageV1VolumeAttachmentList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttachmentList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttachmentList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttachmentList"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttachmentList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttachmentList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttributesClassParameters + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttributesClassParameters}, value) = _decode(IoK8sApiStorageV1VolumeAttributesClassParameters, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttributesClassParameters}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass/properties/parameters"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttributesClassParameters"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttributesClassParameters") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttributesClassParameters(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttributesClassParameters) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass/properties/parameters"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttributesClassParameters"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttributesClassParameters) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttributesClass + apiversion::Union{Absent,Nothing,String} = ABSENT + drivername::String + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + parameters::Union{Absent,IoK8sApiStorageV1VolumeAttributesClassParameters,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttributesClass}, value) = _decode(IoK8sApiStorageV1VolumeAttributesClass, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttributesClass}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttributesClass"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttributesClass") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_drivername = _decode(String, _required(_openapi_object, "driverName", "IoK8sApiStorageV1VolumeAttributesClass"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_parameters = haskey(_openapi_object, "parameters") ? _decode(Union{Absent,IoK8sApiStorageV1VolumeAttributesClassParameters,Nothing}, _openapi_object["parameters"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","driverName","kind","metadata","parameters") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttributesClass(; apiversion = _openapi_field_apiversion, drivername = _openapi_field_drivername, kind = _openapi_field_kind, metadata = _openapi_field_metadata, parameters = _openapi_field_parameters, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttributesClass) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.drivername isa Absent || (_openapi_output["driverName"] = _encode(_openapi_value.drivername)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.parameters isa Absent || (_openapi_output["parameters"] = _encode(_openapi_value.parameters)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClass"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttributesClass"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttributesClass) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.drivername isa Absent || push!(_openapi_output, "driverName" => _openapi_value.drivername) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.parameters isa Absent || push!(_openapi_output, "parameters" => _openapi_value.parameters) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiStorageV1VolumeAttributesClassList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiStorageV1VolumeAttributesClass}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiStorageV1VolumeAttributesClassList}, value) = _decode(IoK8sApiStorageV1VolumeAttributesClassList, value, true) +function _decode(::Type{IoK8sApiStorageV1VolumeAttributesClassList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList"), _openapi_raw, "decoding IoK8sApiStorageV1VolumeAttributesClassList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiStorageV1VolumeAttributesClassList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiStorageV1VolumeAttributesClass}}, _required(_openapi_object, "items", "IoK8sApiStorageV1VolumeAttributesClassList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiStorageV1VolumeAttributesClassList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiStorageV1VolumeAttributesClassList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.api.storage.v1.VolumeAttributesClassList"), _openapi_output, "encoding IoK8sApiStorageV1VolumeAttributesClassList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiStorageV1VolumeAttributesClassList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getstoragev1apiresources = ( + id = "getStorageV1APIResources", + method = "GET", + path = "/apis/storage.k8s.io/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getstoragev1apiresources(...)\n\nget available resources\n\n`GET /apis/storage.k8s.io/v1/`" +function getstoragev1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getstoragev1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectioncsidriver = ( + id = "deleteStorageV1CollectionCSIDriver", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/csidrivers", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectioncsidriver(...)\n\ndelete collection of CSIDriver\n\n`DELETE /apis/storage.k8s.io/v1/csidrivers`" +function deletestoragev1collectioncsidriver(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectioncsidriver, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1csidriver = ( + id = "listStorageV1CSIDriver", + method = "GET", + path = "/apis/storage.k8s.io/v1/csidrivers", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriverList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1csidriver(...)\n\nlist or watch objects of kind CSIDriver\n\n`GET /apis/storage.k8s.io/v1/csidrivers`" +function liststoragev1csidriver(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1csidriver, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1csidriver = ( + id = "createStorageV1CSIDriver", + method = "POST", + path = "/apis/storage.k8s.io/v1/csidrivers", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1csidriver(...)\n\ncreate a CSIDriver\n\n`POST /apis/storage.k8s.io/v1/csidrivers`" +function createstoragev1csidriver(body::IoK8sApiStorageV1CSIDriver; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1csidriver, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1csidriver = ( + id = "deleteStorageV1CSIDriver", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/csidrivers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1csidriver(...)\n\ndelete a CSIDriver\n\n`DELETE /apis/storage.k8s.io/v1/csidrivers/{name}`" +function deletestoragev1csidriver(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1csidriver, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1csidriver = ( + id = "readStorageV1CSIDriver", + method = "GET", + path = "/apis/storage.k8s.io/v1/csidrivers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1csidriver(...)\n\nread the specified CSIDriver\n\n`GET /apis/storage.k8s.io/v1/csidrivers/{name}`" +function readstoragev1csidriver(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1csidriver, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1csidriver = ( + id = "patchStorageV1CSIDriver", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/csidrivers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1csidriver(...)\n\npartially update the specified CSIDriver\n\n`PATCH /apis/storage.k8s.io/v1/csidrivers/{name}`" +function patchstoragev1csidriver(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1csidriver, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1csidriver = ( + id = "replaceStorageV1CSIDriver", + method = "PUT", + path = "/apis/storage.k8s.io/v1/csidrivers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIDriver, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csidrivers~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1csidriver(...)\n\nreplace the specified CSIDriver\n\n`PUT /apis/storage.k8s.io/v1/csidrivers/{name}`" +function replacestoragev1csidriver(name::String, body::IoK8sApiStorageV1CSIDriver; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1csidriver, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectioncsinode = ( + id = "deleteStorageV1CollectionCSINode", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/csinodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectioncsinode(...)\n\ndelete collection of CSINode\n\n`DELETE /apis/storage.k8s.io/v1/csinodes`" +function deletestoragev1collectioncsinode(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectioncsinode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1csinode = ( + id = "listStorageV1CSINode", + method = "GET", + path = "/apis/storage.k8s.io/v1/csinodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINodeList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1csinode(...)\n\nlist or watch objects of kind CSINode\n\n`GET /apis/storage.k8s.io/v1/csinodes`" +function liststoragev1csinode(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1csinode, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1csinode = ( + id = "createStorageV1CSINode", + method = "POST", + path = "/apis/storage.k8s.io/v1/csinodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1csinode(...)\n\ncreate a CSINode\n\n`POST /apis/storage.k8s.io/v1/csinodes`" +function createstoragev1csinode(body::IoK8sApiStorageV1CSINode; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1csinode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1csinode = ( + id = "deleteStorageV1CSINode", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/csinodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1csinode(...)\n\ndelete a CSINode\n\n`DELETE /apis/storage.k8s.io/v1/csinodes/{name}`" +function deletestoragev1csinode(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1csinode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1csinode = ( + id = "readStorageV1CSINode", + method = "GET", + path = "/apis/storage.k8s.io/v1/csinodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1csinode(...)\n\nread the specified CSINode\n\n`GET /apis/storage.k8s.io/v1/csinodes/{name}`" +function readstoragev1csinode(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1csinode, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1csinode = ( + id = "patchStorageV1CSINode", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/csinodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1csinode(...)\n\npartially update the specified CSINode\n\n`PATCH /apis/storage.k8s.io/v1/csinodes/{name}`" +function patchstoragev1csinode(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1csinode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1csinode = ( + id = "replaceStorageV1CSINode", + method = "PUT", + path = "/apis/storage.k8s.io/v1/csinodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSINode, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csinodes~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1csinode(...)\n\nreplace the specified CSINode\n\n`PUT /apis/storage.k8s.io/v1/csinodes/{name}`" +function replacestoragev1csinode(name::String, body::IoK8sApiStorageV1CSINode; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1csinode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1csistoragecapacityforallnamespaces = ( + id = "listStorageV1CSIStorageCapacityForAllNamespaces", + method = "GET", + path = "/apis/storage.k8s.io/v1/csistoragecapacities", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1csistoragecapacities/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1csistoragecapacityforallnamespaces(...)\n\nlist or watch objects of kind CSIStorageCapacity\n\n`GET /apis/storage.k8s.io/v1/csistoragecapacities`" +function liststoragev1csistoragecapacityforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1csistoragecapacityforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectionnamespacedcsistoragecapacity = ( + id = "deleteStorageV1CollectionNamespacedCSIStorageCapacity", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectionnamespacedcsistoragecapacity(...)\n\ndelete collection of CSIStorageCapacity\n\n`DELETE /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities`" +function deletestoragev1collectionnamespacedcsistoragecapacity(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectionnamespacedcsistoragecapacity, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1namespacedcsistoragecapacity = ( + id = "listStorageV1NamespacedCSIStorageCapacity", + method = "GET", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacityList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1namespacedcsistoragecapacity(...)\n\nlist or watch objects of kind CSIStorageCapacity\n\n`GET /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities`" +function liststoragev1namespacedcsistoragecapacity(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1namespacedcsistoragecapacity, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1namespacedcsistoragecapacity = ( + id = "createStorageV1NamespacedCSIStorageCapacity", + method = "POST", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1namespacedcsistoragecapacity(...)\n\ncreate a CSIStorageCapacity\n\n`POST /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities`" +function createstoragev1namespacedcsistoragecapacity(namespace::String, body::IoK8sApiStorageV1CSIStorageCapacity; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1namespacedcsistoragecapacity, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1namespacedcsistoragecapacity = ( + id = "deleteStorageV1NamespacedCSIStorageCapacity", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1namespacedcsistoragecapacity(...)\n\ndelete a CSIStorageCapacity\n\n`DELETE /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}`" +function deletestoragev1namespacedcsistoragecapacity(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1namespacedcsistoragecapacity, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1namespacedcsistoragecapacity = ( + id = "readStorageV1NamespacedCSIStorageCapacity", + method = "GET", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1namespacedcsistoragecapacity(...)\n\nread the specified CSIStorageCapacity\n\n`GET /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}`" +function readstoragev1namespacedcsistoragecapacity(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1namespacedcsistoragecapacity, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1namespacedcsistoragecapacity = ( + id = "patchStorageV1NamespacedCSIStorageCapacity", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1namespacedcsistoragecapacity(...)\n\npartially update the specified CSIStorageCapacity\n\n`PATCH /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}`" +function patchstoragev1namespacedcsistoragecapacity(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1namespacedcsistoragecapacity, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1namespacedcsistoragecapacity = ( + id = "replaceStorageV1NamespacedCSIStorageCapacity", + method = "PUT", + path = "/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1CSIStorageCapacity, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1namespaces~1{namespace}~1csistoragecapacities~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1namespacedcsistoragecapacity(...)\n\nreplace the specified CSIStorageCapacity\n\n`PUT /apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}`" +function replacestoragev1namespacedcsistoragecapacity(namespace::String, name::String, body::IoK8sApiStorageV1CSIStorageCapacity; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1namespacedcsistoragecapacity, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectionstorageclass = ( + id = "deleteStorageV1CollectionStorageClass", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/storageclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectionstorageclass(...)\n\ndelete collection of StorageClass\n\n`DELETE /apis/storage.k8s.io/v1/storageclasses`" +function deletestoragev1collectionstorageclass(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectionstorageclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1storageclass = ( + id = "listStorageV1StorageClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/storageclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1storageclass(...)\n\nlist or watch objects of kind StorageClass\n\n`GET /apis/storage.k8s.io/v1/storageclasses`" +function liststoragev1storageclass(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1storageclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1storageclass = ( + id = "createStorageV1StorageClass", + method = "POST", + path = "/apis/storage.k8s.io/v1/storageclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1storageclass(...)\n\ncreate a StorageClass\n\n`POST /apis/storage.k8s.io/v1/storageclasses`" +function createstoragev1storageclass(body::IoK8sApiStorageV1StorageClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1storageclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1storageclass = ( + id = "deleteStorageV1StorageClass", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/storageclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1storageclass(...)\n\ndelete a StorageClass\n\n`DELETE /apis/storage.k8s.io/v1/storageclasses/{name}`" +function deletestoragev1storageclass(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1storageclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1storageclass = ( + id = "readStorageV1StorageClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/storageclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1storageclass(...)\n\nread the specified StorageClass\n\n`GET /apis/storage.k8s.io/v1/storageclasses/{name}`" +function readstoragev1storageclass(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1storageclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1storageclass = ( + id = "patchStorageV1StorageClass", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/storageclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1storageclass(...)\n\npartially update the specified StorageClass\n\n`PATCH /apis/storage.k8s.io/v1/storageclasses/{name}`" +function patchstoragev1storageclass(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1storageclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1storageclass = ( + id = "replaceStorageV1StorageClass", + method = "PUT", + path = "/apis/storage.k8s.io/v1/storageclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1StorageClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1storageclasses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1storageclass(...)\n\nreplace the specified StorageClass\n\n`PUT /apis/storage.k8s.io/v1/storageclasses/{name}`" +function replacestoragev1storageclass(name::String, body::IoK8sApiStorageV1StorageClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1storageclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectionvolumeattachment = ( + id = "deleteStorageV1CollectionVolumeAttachment", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/volumeattachments", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectionvolumeattachment(...)\n\ndelete collection of VolumeAttachment\n\n`DELETE /apis/storage.k8s.io/v1/volumeattachments`" +function deletestoragev1collectionvolumeattachment(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectionvolumeattachment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1volumeattachment = ( + id = "listStorageV1VolumeAttachment", + method = "GET", + path = "/apis/storage.k8s.io/v1/volumeattachments", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachmentList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1volumeattachment(...)\n\nlist or watch objects of kind VolumeAttachment\n\n`GET /apis/storage.k8s.io/v1/volumeattachments`" +function liststoragev1volumeattachment(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1volumeattachment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1volumeattachment = ( + id = "createStorageV1VolumeAttachment", + method = "POST", + path = "/apis/storage.k8s.io/v1/volumeattachments", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1volumeattachment(...)\n\ncreate a VolumeAttachment\n\n`POST /apis/storage.k8s.io/v1/volumeattachments`" +function createstoragev1volumeattachment(body::IoK8sApiStorageV1VolumeAttachment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1volumeattachment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1volumeattachment = ( + id = "deleteStorageV1VolumeAttachment", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1volumeattachment(...)\n\ndelete a VolumeAttachment\n\n`DELETE /apis/storage.k8s.io/v1/volumeattachments/{name}`" +function deletestoragev1volumeattachment(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1volumeattachment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1volumeattachment = ( + id = "readStorageV1VolumeAttachment", + method = "GET", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1volumeattachment(...)\n\nread the specified VolumeAttachment\n\n`GET /apis/storage.k8s.io/v1/volumeattachments/{name}`" +function readstoragev1volumeattachment(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1volumeattachment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1volumeattachment = ( + id = "patchStorageV1VolumeAttachment", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1volumeattachment(...)\n\npartially update the specified VolumeAttachment\n\n`PATCH /apis/storage.k8s.io/v1/volumeattachments/{name}`" +function patchstoragev1volumeattachment(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1volumeattachment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1volumeattachment = ( + id = "replaceStorageV1VolumeAttachment", + method = "PUT", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1volumeattachment(...)\n\nreplace the specified VolumeAttachment\n\n`PUT /apis/storage.k8s.io/v1/volumeattachments/{name}`" +function replacestoragev1volumeattachment(name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1volumeattachment, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1volumeattachmentstatus = ( + id = "readStorageV1VolumeAttachmentStatus", + method = "GET", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1volumeattachmentstatus(...)\n\nread status of the specified VolumeAttachment\n\n`GET /apis/storage.k8s.io/v1/volumeattachments/{name}/status`" +function readstoragev1volumeattachmentstatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readstoragev1volumeattachmentstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1volumeattachmentstatus = ( + id = "patchStorageV1VolumeAttachmentStatus", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1volumeattachmentstatus(...)\n\npartially update status of the specified VolumeAttachment\n\n`PATCH /apis/storage.k8s.io/v1/volumeattachments/{name}/status`" +function patchstoragev1volumeattachmentstatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1volumeattachmentstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1volumeattachmentstatus = ( + id = "replaceStorageV1VolumeAttachmentStatus", + method = "PUT", + path = "/apis/storage.k8s.io/v1/volumeattachments/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttachment, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattachments~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1volumeattachmentstatus(...)\n\nreplace status of the specified VolumeAttachment\n\n`PUT /apis/storage.k8s.io/v1/volumeattachments/{name}/status`" +function replacestoragev1volumeattachmentstatus(name::String, body::IoK8sApiStorageV1VolumeAttachment; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1volumeattachmentstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1collectionvolumeattributesclass = ( + id = "deleteStorageV1CollectionVolumeAttributesClass", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1collectionvolumeattributesclass(...)\n\ndelete collection of VolumeAttributesClass\n\n`DELETE /apis/storage.k8s.io/v1/volumeattributesclasses`" +function deletestoragev1collectionvolumeattributesclass(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletestoragev1collectionvolumeattributesclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_liststoragev1volumeattributesclass = ( + id = "listStorageV1VolumeAttributesClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClassList, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " liststoragev1volumeattributesclass(...)\n\nlist or watch objects of kind VolumeAttributesClass\n\n`GET /apis/storage.k8s.io/v1/volumeattributesclasses`" +function liststoragev1volumeattributesclass(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_liststoragev1volumeattributesclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createstoragev1volumeattributesclass = ( + id = "createStorageV1VolumeAttributesClass", + method = "POST", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createstoragev1volumeattributesclass(...)\n\ncreate a VolumeAttributesClass\n\n`POST /apis/storage.k8s.io/v1/volumeattributesclasses`" +function createstoragev1volumeattributesclass(body::IoK8sApiStorageV1VolumeAttributesClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createstoragev1volumeattributesclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletestoragev1volumeattributesclass = ( + id = "deleteStorageV1VolumeAttributesClass", + method = "DELETE", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletestoragev1volumeattributesclass(...)\n\ndelete a VolumeAttributesClass\n\n`DELETE /apis/storage.k8s.io/v1/volumeattributesclasses/{name}`" +function deletestoragev1volumeattributesclass(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletestoragev1volumeattributesclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readstoragev1volumeattributesclass = ( + id = "readStorageV1VolumeAttributesClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readstoragev1volumeattributesclass(...)\n\nread the specified VolumeAttributesClass\n\n`GET /apis/storage.k8s.io/v1/volumeattributesclasses/{name}`" +function readstoragev1volumeattributesclass(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readstoragev1volumeattributesclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchstoragev1volumeattributesclass = ( + id = "patchStorageV1VolumeAttributesClass", + method = "PATCH", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchstoragev1volumeattributesclass(...)\n\npartially update the specified VolumeAttributesClass\n\n`PATCH /apis/storage.k8s.io/v1/volumeattributesclasses/{name}`" +function patchstoragev1volumeattributesclass(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchstoragev1volumeattributesclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacestoragev1volumeattributesclass = ( + id = "replaceStorageV1VolumeAttributesClass", + method = "PUT", + path = "/apis/storage.k8s.io/v1/volumeattributesclasses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiStorageV1VolumeAttributesClass, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1volumeattributesclasses~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacestoragev1volumeattributesclass(...)\n\nreplace the specified VolumeAttributesClass\n\n`PUT /apis/storage.k8s.io/v1/volumeattributesclasses/{name}`" +function replacestoragev1volumeattributesclass(name::String, body::IoK8sApiStorageV1VolumeAttributesClass; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacestoragev1volumeattributesclass, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1csidriverlist = ( + id = "watchStorageV1CSIDriverList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/csidrivers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1csidriverlist(...)\n\nwatch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/csidrivers`" +function watchstoragev1csidriverlist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1csidriverlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1csidriver = ( + id = "watchStorageV1CSIDriver", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/csidrivers/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csidrivers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1csidriver(...)\n\nwatch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/csidrivers/{name}`" +function watchstoragev1csidriver(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1csidriver, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1csinodelist = ( + id = "watchStorageV1CSINodeList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/csinodes", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1csinodelist(...)\n\nwatch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/csinodes`" +function watchstoragev1csinodelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1csinodelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1csinode = ( + id = "watchStorageV1CSINode", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/csinodes/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csinodes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1csinode(...)\n\nwatch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/csinodes/{name}`" +function watchstoragev1csinode(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1csinode, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1csistoragecapacitylistforallnamespaces = ( + id = "watchStorageV1CSIStorageCapacityListForAllNamespaces", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/csistoragecapacities", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1csistoragecapacities/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1csistoragecapacitylistforallnamespaces(...)\n\nwatch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/csistoragecapacities`" +function watchstoragev1csistoragecapacitylistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1csistoragecapacitylistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1namespacedcsistoragecapacitylist = ( + id = "watchStorageV1NamespacedCSIStorageCapacityList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1namespacedcsistoragecapacitylist(...)\n\nwatch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities`" +function watchstoragev1namespacedcsistoragecapacitylist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1namespacedcsistoragecapacitylist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1namespacedcsistoragecapacity = ( + id = "watchStorageV1NamespacedCSIStorageCapacity", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1namespaces~1{namespace}~1csistoragecapacities~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1namespacedcsistoragecapacity(...)\n\nwatch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}`" +function watchstoragev1namespacedcsistoragecapacity(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1namespacedcsistoragecapacity, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1storageclasslist = ( + id = "watchStorageV1StorageClassList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/storageclasses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1storageclasslist(...)\n\nwatch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/storageclasses`" +function watchstoragev1storageclasslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1storageclasslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1storageclass = ( + id = "watchStorageV1StorageClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/storageclasses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1storageclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1storageclass(...)\n\nwatch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/storageclasses/{name}`" +function watchstoragev1storageclass(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1storageclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1volumeattachmentlist = ( + id = "watchStorageV1VolumeAttachmentList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/volumeattachments", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1volumeattachmentlist(...)\n\nwatch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/volumeattachments`" +function watchstoragev1volumeattachmentlist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1volumeattachmentlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1volumeattachment = ( + id = "watchStorageV1VolumeAttachment", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/volumeattachments/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattachments~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1volumeattachment(...)\n\nwatch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/volumeattachments/{name}`" +function watchstoragev1volumeattachment(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1volumeattachment, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1volumeattributesclasslist = ( + id = "watchStorageV1VolumeAttributesClassList", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/volumeattributesclasses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1volumeattributesclasslist(...)\n\nwatch individual changes to a list of VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /apis/storage.k8s.io/v1/watch/volumeattributesclasses`" +function watchstoragev1volumeattributesclasslist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1volumeattributesclasslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchstoragev1volumeattributesclass = ( + id = "watchStorageV1VolumeAttributesClass", + method = "GET", + path = "/apis/storage.k8s.io/v1/watch/volumeattributesclasses/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-3214defad8ecff6cb055.json", pointer = "/paths/~1apis~1storage.k8s.io~1v1~1watch~1volumeattributesclasses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchstoragev1volumeattributesclass(...)\n\nwatch changes to an object of kind VolumeAttributesClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /apis/storage.k8s.io/v1/watch/volumeattributesclasses/{name}`" +function watchstoragev1volumeattributesclass(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchstoragev1volumeattributesclass, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sStorageK8sIoV1 diff --git a/src/ApiImpl/generated/K8sV1.jl b/src/ApiImpl/generated/K8sV1.jl new file mode 100644 index 00000000..ad9b7c9c --- /dev/null +++ b/src/ApiImpl/generated/K8sV1.jl @@ -0,0 +1,23073 @@ +# Generated by OpenAPI.jl from "Kubernetes" version "unversioned". Do not edit. +module K8sV1 + +using HTTP, JSON, OpenAPI, Base64, Dates, UUIDs +const Runtime = OpenAPI.Runtime +const SchemaEngine = OpenAPI.SchemaEngine +import OpenAPI.Runtime: + ABSENT, Absent, AbstractCredential, ApiError, ApiKeyCredential, ApiResponse, + BasicCredential, BearerCredential, DecodeError, HttpCredential, + MultipartPartHeaders, MutualTLSCredential, SchemaValidationError, + UnexpectedBody, UnexpectedContentType, UnsupportedMediaType, Upload, + _decode, _encode, _form_fields, _object, _required, _request, + _schema_valid, _validate_schema + +const _SECURITY_SCHEMES = Dict{String,NamedTuple}( + "BearerToken" => (type = :apikey, location = :header, name = "authorization", scheme = ""), +) + +const _SCHEMA_RESOURCE_DATA = Any[ + (id = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", retrieval = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", media_type = "application/openapi+json", json = "{\"components\":{\"schemas\":{\"io.k8s.api.authentication.v1.BoundObjectReference\":{\"description\":\"BoundObjectReference is a reference to an object that a token is bound to.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. Valid kinds are 'Pod' and 'Secret'.\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.authentication.v1.TokenRequest\":{\"description\":\"TokenRequest requests a token for a given service account.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus\"}},\"required\":[\"spec\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"authentication.k8s.io\",\"kind\":\"TokenRequest\",\"version\":\"v1\"}]},\"io.k8s.api.authentication.v1.TokenRequestSpec\":{\"description\":\"TokenRequestSpec contains client provided parameters of a token request.\",\"properties\":{\"audiences\":{\"description\":\"Audiences are the intendend audiences of the token. A recipient of a token must identify themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"boundObjectRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference\"},\"expirationSeconds\":{\"description\":\"ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"audiences\"],\"type\":\"object\"},\"io.k8s.api.authentication.v1.TokenRequestStatus\":{\"description\":\"TokenRequestStatus is the result of a token request.\",\"properties\":{\"expirationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"token\":{\"default\":\"\",\"description\":\"Token is the opaque bearer token.\",\"type\":\"string\"}},\"required\":[\"token\",\"expirationTimestamp\"],\"type\":\"object\"},\"io.k8s.api.autoscaling.v1.Scale\":{\"description\":\"Scale represents a scaling request for a resource.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}]},\"io.k8s.api.autoscaling.v1.ScaleSpec\":{\"description\":\"ScaleSpec describes the attributes of a scale subresource.\",\"properties\":{\"replicas\":{\"default\":0,\"description\":\"replicas is the desired number of instances for the scaled object.\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.autoscaling.v1.ScaleStatus\":{\"description\":\"ScaleStatus represents the current status of a scale subresource.\",\"properties\":{\"replicas\":{\"default\":0,\"description\":\"replicas is the actual number of observed instances of the scaled object.\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"description\":\"selector is the label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/\",\"type\":\"string\"}},\"required\":[\"replicas\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in AWS.\\n\\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty).\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Affinity\":{\"description\":\"Affinity is a group of affinity scheduling rules.\",\"properties\":{\"nodeAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeAffinity\"},\"podAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodAffinity\"},\"podAntiAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodAntiAffinity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.AppArmorProfile\":{\"description\":\"AppArmorProfile defines a pod or container's AppArmor settings.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile loaded on the node that should be used. The profile must be preconfigured on the node to work. Must match the loaded name of the profile. Must be set if and only if type is \\\"Localhost\\\".\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of AppArmor profile will be applied. Valid options are:\\n Localhost - a profile pre-loaded on the node.\\n RuntimeDefault - the container runtime's default profile.\\n Unconfined - no AppArmor enforcement.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.AttachedVolume\":{\"description\":\"AttachedVolume describes a volume attached to a node\",\"properties\":{\"devicePath\":{\"default\":\"\",\"description\":\"DevicePath represents the device path where the volume should be available\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the attached volume\",\"type\":\"string\"}},\"required\":[\"name\",\"devicePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureDiskVolumeSource\":{\"description\":\"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.\",\"properties\":{\"cachingMode\":{\"default\":\"ReadWrite\",\"description\":\"cachingMode is the Host Caching mode: None, Read Only, Read Write.\",\"type\":\"string\"},\"diskName\":{\"default\":\"\",\"description\":\"diskName is the Name of the data disk in the blob storage\",\"type\":\"string\"},\"diskURI\":{\"default\":\"\",\"description\":\"diskURI is the URI of data disk in the blob storage\",\"type\":\"string\"},\"fsType\":{\"default\":\"ext4\",\"description\":\"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"kind\":{\"default\":\"Shared\",\"description\":\"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared\",\"type\":\"string\"},\"readOnly\":{\"default\":false,\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"}},\"required\":[\"diskName\",\"diskURI\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureFilePersistentVolumeSource\":{\"description\":\"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.\",\"properties\":{\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretName\":{\"default\":\"\",\"description\":\"secretName is the name of secret that contains Azure Storage Account Name and Key\",\"type\":\"string\"},\"secretNamespace\":{\"description\":\"secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod\",\"type\":\"string\"},\"shareName\":{\"default\":\"\",\"description\":\"shareName is the azure Share Name\",\"type\":\"string\"}},\"required\":[\"secretName\",\"shareName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.AzureFileVolumeSource\":{\"description\":\"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.\",\"properties\":{\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretName\":{\"default\":\"\",\"description\":\"secretName is the name of secret that contains Azure Storage Account Name and Key\",\"type\":\"string\"},\"shareName\":{\"default\":\"\",\"description\":\"shareName is the azure share Name\",\"type\":\"string\"}},\"required\":[\"secretName\",\"shareName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Binding\":{\"description\":\"Binding ties one object to another; for example, a pod is bound to a node by a scheduler.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"target\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"}},\"required\":[\"target\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Binding\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.CSIPersistentVolumeSource\":{\"description\":\"Represents storage that is managed by an external CSI volume driver\",\"properties\":{\"controllerExpandSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"controllerPublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume. Required.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\".\",\"type\":\"string\"},\"nodeExpandSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"nodePublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"nodeStageSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"readOnly\":{\"description\":\"readOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).\",\"type\":\"boolean\"},\"volumeAttributes\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"volumeAttributes of the volume to publish.\",\"type\":\"object\"},\"volumeHandle\":{\"default\":\"\",\"description\":\"volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.\",\"type\":\"string\"}},\"required\":[\"driver\",\"volumeHandle\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CSIVolumeSource\":{\"description\":\"Represents a source location of a volume to mount, managed by an external CSI driver\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType to mount. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.\",\"type\":\"string\"},\"nodePublishSecretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"readOnly\":{\"description\":\"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).\",\"type\":\"boolean\"},\"volumeAttributes\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.\",\"type\":\"object\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Capabilities\":{\"description\":\"Adds and removes POSIX capabilities from running containers.\",\"properties\":{\"add\":{\"description\":\"Added capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"drop\":{\"description\":\"Removed capabilities\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.CephFSPersistentVolumeSource\":{\"description\":\"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"monitors\":{\"description\":\"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretFile\":{\"description\":\"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"user\":{\"description\":\"user is Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CephFSVolumeSource\":{\"description\":\"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"monitors\":{\"description\":\"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretFile\":{\"description\":\"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"description\":\"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CinderPersistentVolumeSource\":{\"description\":\"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.CinderVolumeSource\":{\"description\":\"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ClientIPConfig\":{\"description\":\"ClientIPConfig represents the configurations of Client IP based session affinity.\",\"properties\":{\"timeoutSeconds\":{\"description\":\"timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \\\"ClientIP\\\". Default value is 10800(for 3 hours).\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ClusterTrustBundleProjection\":{\"description\":\"ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"name\":{\"description\":\"Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector.\",\"type\":\"string\"},\"optional\":{\"description\":\"If true, don't block pod startup if the referenced ClusterTrustBundle(s) aren't available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"Relative path from the volume root to write the bundle.\",\"type\":\"string\"},\"signerName\":{\"description\":\"Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ComponentCondition\":{\"description\":\"Information about the condition of a component.\",\"properties\":{\"error\":{\"description\":\"Condition error code for a component. For example, a health check error code.\",\"type\":\"string\"},\"message\":{\"description\":\"Message about the condition for a component. For example, information about a health check.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition for a component. Valid values for \\\"Healthy\\\": \\\"True\\\", \\\"False\\\", or \\\"Unknown\\\".\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of condition for a component. Valid value: \\\"Healthy\\\"\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ComponentStatus\":{\"description\":\"ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"conditions\":{\"description\":\"List of component conditions observed\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ComponentStatus\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ComponentStatusList\":{\"description\":\"Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of ComponentStatus objects.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatus\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ComponentStatusList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ConfigMap\":{\"description\":\"ConfigMap holds configuration data for pods to consume.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"binaryData\":{\"additionalProperties\":{\"format\":\"byte\",\"type\":\"string\"},\"description\":\"BinaryData contains the binary data. Each key must consist of alphanumeric characters, '-', '_' or '.'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet.\",\"type\":\"object\"},\"data\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Data contains the configuration data. Each key must consist of alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process.\",\"type\":\"object\"},\"immutable\":{\"description\":\"Immutable, if set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ConfigMapEnvSource\":{\"description\":\"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\\n\\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapKeySelector\":{\"description\":\"Selects a key from a ConfigMap.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key to select.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the ConfigMap or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ConfigMapList\":{\"description\":\"ConfigMapList is a resource containing a list of ConfigMap objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of ConfigMaps.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ConfigMapList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ConfigMapNodeConfigSource\":{\"description\":\"ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration\",\"properties\":{\"kubeletConfigKey\":{\"default\":\"\",\"description\":\"KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the metadata.name of the referenced ConfigMap. This field is required in all cases.\",\"type\":\"string\"},\"namespace\":{\"default\":\"\",\"description\":\"Namespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases.\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status.\",\"type\":\"string\"}},\"required\":[\"namespace\",\"name\",\"kubeletConfigKey\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapProjection\":{\"description\":\"Adapts a ConfigMap into a projected volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ConfigMapVolumeSource\":{\"description\":\"Adapts a ConfigMap into a volume.\\n\\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional specify whether the ConfigMap or its keys must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Container\":{\"description\":\"A single application container that you want to run within a pod.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.\",\"type\":\"string\"},\"ports\":{\"description\":\"List of ports to expose from the container. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \\\"0.0.0.0\\\" address inside a container will be accessible from the network. Modifying this array with strategic merge patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container. This field cannot be set on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \\\"Always\\\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \\\"Always\\\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \\\"sidecar\\\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerExtendedResourceRequest\":{\"description\":\"ContainerExtendedResourceRequest has the mapping of container name, extended resource name to the device request name.\",\"properties\":{\"containerName\":{\"default\":\"\",\"description\":\"The name of the container requesting resources.\",\"type\":\"string\"},\"requestName\":{\"default\":\"\",\"description\":\"The name of the request in the special ResourceClaim which corresponds to the extended resource.\",\"type\":\"string\"},\"resourceName\":{\"default\":\"\",\"description\":\"The name of the extended resource in that container which gets backed by DRA.\",\"type\":\"string\"}},\"required\":[\"containerName\",\"resourceName\",\"requestName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerImage\":{\"description\":\"Describe a container image\",\"properties\":{\"names\":{\"description\":\"Names by which this image is known. e.g. [\\\"kubernetes.example/hyperkube:v1.0.7\\\", \\\"cloud-vendor.registry.example/cloud-vendor/hyperkube:v1.0.7\\\"]\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"sizeBytes\":{\"description\":\"The size of the image in bytes.\",\"format\":\"int64\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerPort\":{\"description\":\"ContainerPort represents a network port in a single container.\",\"properties\":{\"containerPort\":{\"default\":0,\"description\":\"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.\",\"format\":\"int32\",\"type\":\"integer\"},\"hostIP\":{\"description\":\"What host IP to bind the external port to.\",\"type\":\"string\"},\"hostPort\":{\"description\":\"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.\",\"format\":\"int32\",\"type\":\"integer\"},\"name\":{\"description\":\"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.\",\"type\":\"string\"},\"protocol\":{\"default\":\"TCP\",\"description\":\"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \\\"TCP\\\".\",\"type\":\"string\"}},\"required\":[\"containerPort\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerResizePolicy\":{\"description\":\"ContainerResizePolicy represents resource resize policy for the container.\",\"properties\":{\"resourceName\":{\"default\":\"\",\"description\":\"Name of the resource to which this resource resize policy applies. Supported values: cpu, memory.\",\"type\":\"string\"},\"restartPolicy\":{\"default\":\"\",\"description\":\"Restart policy to apply when specified resource is resized. If not specified, it defaults to NotRequired.\",\"type\":\"string\"}},\"required\":[\"resourceName\",\"restartPolicy\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRule\":{\"description\":\"ContainerRestartRule describes how a container exit is handled.\",\"properties\":{\"action\":{\"description\":\"Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \\\"Restart\\\" to restart the container.\",\"type\":\"string\"},\"exitCodes\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\"}},\"required\":[\"action\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes\":{\"description\":\"ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.\",\"properties\":{\"operator\":{\"description\":\"Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\\n set of specified values.\\n- NotIn: the requirement is satisfied if the container exit code is\\n not in the set of specified values.\",\"type\":\"string\"},\"values\":{\"description\":\"Specifies the set of values to check for container exit codes. At most 255 elements are allowed.\",\"items\":{\"default\":0,\"format\":\"int32\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"nullable\":true}},\"required\":[\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerState\":{\"description\":\"ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.\",\"properties\":{\"running\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStateRunning\"},\"terminated\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated\"},\"waiting\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerStateRunning\":{\"description\":\"ContainerStateRunning is a running state of a container.\",\"properties\":{\"startedAt\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerStateTerminated\":{\"description\":\"ContainerStateTerminated is a terminated state of a container.\",\"properties\":{\"containerID\":{\"description\":\"Container's ID in the format '://'\",\"type\":\"string\"},\"exitCode\":{\"default\":0,\"description\":\"Exit status from the last termination of the container\",\"format\":\"int32\",\"type\":\"integer\"},\"finishedAt\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Message regarding the last termination of the container\",\"type\":\"string\"},\"reason\":{\"description\":\"(brief) reason from the last termination of the container\",\"type\":\"string\"},\"signal\":{\"description\":\"Signal from the last termination of the container\",\"format\":\"int32\",\"type\":\"integer\"},\"startedAt\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"required\":[\"exitCode\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerStateWaiting\":{\"description\":\"ContainerStateWaiting is a waiting state of a container.\",\"properties\":{\"message\":{\"description\":\"Message regarding why the container is not yet running.\",\"type\":\"string\"},\"reason\":{\"description\":\"(brief) reason the container is not yet running.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerStatus\":{\"description\":\"ContainerStatus contains details for the current status of this container.\",\"properties\":{\"allocatedResources\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"AllocatedResources represents the compute resources allocated for this container by the node. Kubelet sets this value to Container.Resources.Requests upon successful pod admission and after successfully admitting desired pod resize.\",\"type\":\"object\"},\"allocatedResourcesStatus\":{\"description\":\"AllocatedResourcesStatus represents the status of various resources allocated for this Pod.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"containerID\":{\"description\":\"ContainerID is the ID of the container in the format '://'. Where type is a container runtime identifier, returned from Version call of CRI API (for example \\\"containerd\\\").\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"Image is the name of container image that the container is running. The container image may not match the image used in the PodSpec, as it may have been resolved by the runtime. More info: https://kubernetes.io/docs/concepts/containers/images.\",\"type\":\"string\"},\"imageID\":{\"default\":\"\",\"description\":\"ImageID is the image ID of the container's image. The image ID may not match the image ID of the image used in the PodSpec, as it may have been resolved by the runtime.\",\"type\":\"string\"},\"lastState\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerState\"},\"name\":{\"default\":\"\",\"description\":\"Name is a DNS_LABEL representing the unique name of the container. Each container in a pod must have a unique name across all container types. Cannot be updated.\",\"type\":\"string\"},\"ready\":{\"default\":false,\"description\":\"Ready specifies whether the container is currently passing its readiness check. The value will change as readiness probes keep executing. If no readiness probes are specified, this field defaults to true once the container is fully started (see Started field).\\n\\nThe value is typically used to determine whether a container is ready to accept traffic.\",\"type\":\"boolean\"},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartCount\":{\"default\":0,\"description\":\"RestartCount holds the number of times the container has been restarted. Kubelet makes an effort to always increment the value, but there are cases when the state may be lost due to node restarts and then the value may be reset to 0. The value is never negative.\",\"format\":\"int32\",\"type\":\"integer\"},\"started\":{\"description\":\"Started indicates whether the container has finished its postStart lifecycle hook and passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. In both cases, startup probes will run again. Is always true when no startupProbe is defined and container is running and has passed the postStart lifecycle hook. The null value must be treated the same as false.\",\"type\":\"boolean\"},\"state\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerState\"},\"stopSignal\":{\"description\":\"StopSignal reports the effective stop signal for this container\",\"type\":\"string\"},\"user\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerUser\"},\"volumeMounts\":{\"description\":\"Status of volume mounts.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeMountStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"required\":[\"name\",\"ready\",\"restartCount\",\"image\",\"imageID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ContainerUser\":{\"description\":\"ContainerUser represents user identity information\",\"properties\":{\"linux\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LinuxContainerUser\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.DaemonEndpoint\":{\"description\":\"DaemonEndpoint contains information about a single Daemon endpoint.\",\"properties\":{\"Port\":{\"default\":0,\"description\":\"Port number of the given endpoint.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"Port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIProjection\":{\"description\":\"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"Items is a list of DownwardAPIVolume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeFile\":{\"description\":\"DownwardAPIVolumeFile represents information to create the file containing the pod field\",\"properties\":{\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"mode\":{\"description\":\"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'\",\"type\":\"string\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.DownwardAPIVolumeSource\":{\"description\":\"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"Items is a list of downward API volume file\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.EmptyDirVolumeSource\":{\"description\":\"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.\",\"properties\":{\"medium\":{\"description\":\"medium represents what type of storage medium should back this directory. The default is \\\"\\\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir\",\"type\":\"string\"},\"sizeLimit\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EndpointAddress\":{\"description\":\"EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.\",\"properties\":{\"hostname\":{\"description\":\"The Hostname of this endpoint\",\"type\":\"string\"},\"ip\":{\"default\":\"\",\"description\":\"The IP of this endpoint. May not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10), or link-local multicast (224.0.0.0/24 or ff02::/16).\",\"type\":\"string\"},\"nodeName\":{\"description\":\"Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.\",\"type\":\"string\"},\"targetRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"}},\"required\":[\"ip\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.EndpointPort\":{\"description\":\"EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.\",\"properties\":{\"appProtocol\":{\"description\":\"The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\\n\\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\\n\\n* Kubernetes-defined prefixed names:\\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\\n\\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.\",\"type\":\"string\"},\"name\":{\"description\":\"The name of this port. This must match the 'name' field in the corresponding ServicePort. Must be a DNS_LABEL. Optional only if one port is defined.\",\"type\":\"string\"},\"port\":{\"default\":0,\"description\":\"The port number of the endpoint.\",\"format\":\"int32\",\"type\":\"integer\"},\"protocol\":{\"description\":\"The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.EndpointSubset\":{\"description\":\"EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given:\\n\\n\\t{\\n\\t Addresses: [{\\\"ip\\\": \\\"10.10.1.1\\\"}, {\\\"ip\\\": \\\"10.10.2.2\\\"}],\\n\\t Ports: [{\\\"name\\\": \\\"a\\\", \\\"port\\\": 8675}, {\\\"name\\\": \\\"b\\\", \\\"port\\\": 309}]\\n\\t}\\n\\nThe resulting set of endpoints can be viewed as:\\n\\n\\ta: [ 10.10.1.1:8675, 10.10.2.2:8675 ],\\n\\tb: [ 10.10.1.1:309, 10.10.2.2:309 ]\\n\\nDeprecated: This API is deprecated in v1.33+.\",\"properties\":{\"addresses\":{\"description\":\"IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointAddress\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"notReadyAddresses\":{\"description\":\"IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointAddress\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ports\":{\"description\":\"Port numbers available on the related IP addresses.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.Endpoints\":{\"description\":\"Endpoints is a collection of endpoints that implement the actual service. Example:\\n\\n\\t Name: \\\"mysvc\\\",\\n\\t Subsets: [\\n\\t {\\n\\t Addresses: [{\\\"ip\\\": \\\"10.10.1.1\\\"}, {\\\"ip\\\": \\\"10.10.2.2\\\"}],\\n\\t Ports: [{\\\"name\\\": \\\"a\\\", \\\"port\\\": 8675}, {\\\"name\\\": \\\"b\\\", \\\"port\\\": 309}]\\n\\t },\\n\\t {\\n\\t Addresses: [{\\\"ip\\\": \\\"10.10.3.3\\\"}],\\n\\t Ports: [{\\\"name\\\": \\\"a\\\", \\\"port\\\": 93}, {\\\"name\\\": \\\"b\\\", \\\"port\\\": 76}]\\n\\t },\\n\\t]\\n\\nEndpoints is a legacy API and does not contain information about all Service features. Use discoveryv1.EndpointSlice for complete information about Service endpoints.\\n\\nDeprecated: This API is deprecated in v1.33+. Use discoveryv1.EndpointSlice.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"subsets\":{\"description\":\"The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointSubset\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.EndpointsList\":{\"description\":\"EndpointsList is a list of endpoints. Deprecated: This API is deprecated in v1.33+.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of endpoints.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"EndpointsList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.EnvFromSource\":{\"description\":\"EnvFromSource represents the source of a set of ConfigMaps or Secrets\",\"properties\":{\"configMapRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource\"},\"prefix\":{\"description\":\"Optional text to prepend to the name of each environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretEnvSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVar\":{\"description\":\"EnvVar represents an environment variable present in a Container.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the environment variable. May consist of any printable ASCII characters except '='.\",\"type\":\"string\"},\"value\":{\"description\":\"Variable references \$(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \\\"\\\".\",\"type\":\"string\"},\"valueFrom\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EnvVarSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EnvVarSource\":{\"description\":\"EnvVarSource represents a source for the value of an EnvVar.\",\"properties\":{\"configMapKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector\"},\"fieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector\"},\"fileKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FileKeySelector\"},\"resourceFieldRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector\"},\"secretKeyRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretKeySelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralContainer\":{\"description\":\"An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\\n\\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.\",\"properties\":{\"args\":{\"description\":\"Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"command\":{\"description\":\"Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references \$(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double \$\$ are reduced to a single \$, which allows for escaping the \$(VAR_NAME) syntax: i.e. \\\"\$\$(VAR_NAME)\\\" will produce the string literal \\\"\$(VAR_NAME)\\\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"env\":{\"description\":\"List of environment variables to set in the container. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EnvVar\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"envFrom\":{\"description\":\"List of sources to populate environment variables in the container. The keys defined within a source may consist of any printable ASCII characters except '='. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EnvFromSource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"image\":{\"description\":\"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images\",\"type\":\"string\"},\"imagePullPolicy\":{\"description\":\"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images\",\"type\":\"string\"},\"lifecycle\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Lifecycle\"},\"livenessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"name\":{\"default\":\"\",\"description\":\"Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers.\",\"type\":\"string\"},\"ports\":{\"description\":\"Ports are not allowed for ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerPort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"containerPort\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"containerPort\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"readinessProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"resizePolicy\":{\"description\":\"Resources resize policy for the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.\",\"type\":\"string\"},\"restartPolicyRules\":{\"description\":\"Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecurityContext\"},\"startupProbe\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Probe\"},\"stdin\":{\"description\":\"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.\",\"type\":\"boolean\"},\"stdinOnce\":{\"description\":\"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false\",\"type\":\"boolean\"},\"targetContainerName\":{\"description\":\"If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\\n\\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.\",\"type\":\"string\"},\"terminationMessagePath\":{\"description\":\"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.\",\"type\":\"string\"},\"terminationMessagePolicy\":{\"description\":\"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.\",\"type\":\"string\"},\"tty\":{\"description\":\"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.\",\"type\":\"boolean\"},\"volumeDevices\":{\"description\":\"volumeDevices is the list of block devices to be used by the container.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeDevice\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"devicePath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"devicePath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumeMounts\":{\"description\":\"Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeMount\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"mountPath\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"mountPath\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"workingDir\":{\"description\":\"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.EphemeralVolumeSource\":{\"description\":\"Represents an ephemeral volume that is handled by a normal storage driver.\",\"properties\":{\"volumeClaimTemplate\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Event\":{\"description\":\"Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.\",\"properties\":{\"action\":{\"description\":\"What action was taken/failed regarding to the Regarding object.\",\"type\":\"string\"},\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"count\":{\"description\":\"The number of times this event has occurred.\",\"format\":\"int32\",\"type\":\"integer\"},\"eventTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"},\"firstTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"involvedObject\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"lastTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"reason\":{\"description\":\"This should be a short, machine understandable string that gives the reason for the transition into the object's current status.\",\"type\":\"string\"},\"related\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"reportingComponent\":{\"default\":\"\",\"description\":\"Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.\",\"type\":\"string\"},\"reportingInstance\":{\"default\":\"\",\"description\":\"ID of the controller instance, e.g. `kubelet-xyzf`.\",\"type\":\"string\"},\"series\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventSeries\"},\"source\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventSource\"},\"type\":{\"description\":\"Type of this event (Normal, Warning), new types could be added in the future\",\"type\":\"string\"}},\"required\":[\"metadata\",\"involvedObject\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.EventList\":{\"description\":\"EventList is a list of events.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of events\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"EventList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.EventSeries\":{\"description\":\"EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.\",\"properties\":{\"count\":{\"description\":\"Number of occurrences in this series up to the last heartbeat time\",\"format\":\"int32\",\"type\":\"integer\"},\"lastObservedTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.EventSource\":{\"description\":\"EventSource contains information for an event.\",\"properties\":{\"component\":{\"description\":\"Component from which the event is generated.\",\"type\":\"string\"},\"host\":{\"description\":\"Node name on which the event is generated.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ExecAction\":{\"description\":\"ExecAction describes a \\\"run in container\\\" action.\",\"properties\":{\"command\":{\"description\":\"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FCVolumeSource\":{\"description\":\"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"lun\":{\"description\":\"lun is Optional: FC target lun number\",\"format\":\"int32\",\"type\":\"integer\"},\"readOnly\":{\"description\":\"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"targetWWNs\":{\"description\":\"targetWWNs is Optional: FC target worldwide names (WWNs)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"wwids\":{\"description\":\"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.FileKeySelector\":{\"description\":\"FileKeySelector selects a key of the env file.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.\",\"type\":\"string\"},\"optional\":{\"default\":false,\"description\":\"Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\\n\\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.\",\"type\":\"boolean\"},\"path\":{\"default\":\"\",\"description\":\"The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.\",\"type\":\"string\"},\"volumeName\":{\"default\":\"\",\"description\":\"The name of the volume mount containing the env file.\",\"type\":\"string\"}},\"required\":[\"volumeName\",\"path\",\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.FlexPersistentVolumeSource\":{\"description\":\"FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default filesystem depends on FlexVolume script.\",\"type\":\"string\"},\"options\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"options is Optional: this field holds extra command options if any.\",\"type\":\"object\"},\"readOnly\":{\"description\":\"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FlexVolumeSource\":{\"description\":\"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.\",\"properties\":{\"driver\":{\"default\":\"\",\"description\":\"driver is the name of the driver to use for this volume.\",\"type\":\"string\"},\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default filesystem depends on FlexVolume script.\",\"type\":\"string\"},\"options\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"options is Optional: this field holds extra command options if any.\",\"type\":\"object\"},\"readOnly\":{\"description\":\"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"}},\"required\":[\"driver\"],\"type\":\"object\"},\"io.k8s.api.core.v1.FlockerVolumeSource\":{\"description\":\"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"datasetName\":{\"description\":\"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated\",\"type\":\"string\"},\"datasetUUID\":{\"description\":\"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\":{\"description\":\"Represents a Persistent Disk resource in Google Compute Engine.\\n\\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"partition\":{\"description\":\"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \\\"1\\\". Similarly, the volume partition for /dev/sda is \\\"0\\\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"format\":\"int32\",\"type\":\"integer\"},\"pdName\":{\"default\":\"\",\"description\":\"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\",\"type\":\"boolean\"}},\"required\":[\"pdName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GRPCAction\":{\"description\":\"GRPCAction specifies an action involving a GRPC service.\",\"properties\":{\"port\":{\"default\":0,\"description\":\"Port number of the gRPC service. Number must be in the range 1 to 65535.\",\"format\":\"int32\",\"type\":\"integer\"},\"service\":{\"default\":\"\",\"description\":\"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\\n\\nIf this is not specified, the default behavior is defined by gRPC.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GitRepoVolumeSource\":{\"description\":\"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\\n\\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.\",\"properties\":{\"directory\":{\"description\":\"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.\",\"type\":\"string\"},\"repository\":{\"default\":\"\",\"description\":\"repository is the URL\",\"type\":\"string\"},\"revision\":{\"description\":\"revision is the commit hash for the specified revision.\",\"type\":\"string\"}},\"required\":[\"repository\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GlusterfsPersistentVolumeSource\":{\"description\":\"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"endpoints\":{\"default\":\"\",\"description\":\"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"endpointsNamespace\":{\"description\":\"endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"boolean\"}},\"required\":[\"endpoints\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.GlusterfsVolumeSource\":{\"description\":\"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"endpoints\":{\"default\":\"\",\"description\":\"endpoints is the endpoint name that details Glusterfs topology.\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod\",\"type\":\"boolean\"}},\"required\":[\"endpoints\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPGetAction\":{\"description\":\"HTTPGetAction describes an action based on HTTP Get requests.\",\"properties\":{\"host\":{\"description\":\"Host name to connect to, defaults to the pod IP. You probably want to set \\\"Host\\\" in httpHeaders instead.\",\"type\":\"string\"},\"httpHeaders\":{\"description\":\"Custom headers to set in the request. HTTP allows repeated headers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HTTPHeader\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"path\":{\"description\":\"Path to access on the HTTP server.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"},\"scheme\":{\"description\":\"Scheme to use for connecting to the host. Defaults to HTTP.\",\"type\":\"string\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HTTPHeader\":{\"description\":\"HTTPHeader describes a custom header to be used in HTTP probes\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header.\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"The header field value\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostAlias\":{\"description\":\"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.\",\"properties\":{\"hostnames\":{\"description\":\"Hostnames for the above IP address.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ip\":{\"default\":\"\",\"description\":\"IP address of the host file entry.\",\"type\":\"string\"}},\"required\":[\"ip\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostIP\":{\"description\":\"HostIP represents a single IP address allocated to the host.\",\"properties\":{\"ip\":{\"default\":\"\",\"description\":\"IP is the IP address assigned to the host\",\"type\":\"string\"}},\"required\":[\"ip\"],\"type\":\"object\"},\"io.k8s.api.core.v1.HostPathVolumeSource\":{\"description\":\"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"},\"type\":{\"description\":\"type for HostPath Volume Defaults to \\\"\\\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ISCSIPersistentVolumeSource\":{\"description\":\"ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.\",\"properties\":{\"chapAuthDiscovery\":{\"description\":\"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication\",\"type\":\"boolean\"},\"chapAuthSession\":{\"description\":\"chapAuthSession defines whether support iSCSI Session CHAP authentication\",\"type\":\"boolean\"},\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi\",\"type\":\"string\"},\"initiatorName\":{\"description\":\"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.\",\"type\":\"string\"},\"iqn\":{\"default\":\"\",\"description\":\"iqn is Target iSCSI Qualified Name.\",\"type\":\"string\"},\"iscsiInterface\":{\"default\":\"default\",\"description\":\"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).\",\"type\":\"string\"},\"lun\":{\"default\":0,\"description\":\"lun is iSCSI Target Lun number.\",\"format\":\"int32\",\"type\":\"integer\"},\"portals\":{\"description\":\"portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"targetPortal\":{\"default\":\"\",\"description\":\"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"type\":\"string\"}},\"required\":[\"targetPortal\",\"iqn\",\"lun\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ISCSIVolumeSource\":{\"description\":\"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.\",\"properties\":{\"chapAuthDiscovery\":{\"description\":\"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication\",\"type\":\"boolean\"},\"chapAuthSession\":{\"description\":\"chapAuthSession defines whether support iSCSI Session CHAP authentication\",\"type\":\"boolean\"},\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi\",\"type\":\"string\"},\"initiatorName\":{\"description\":\"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.\",\"type\":\"string\"},\"iqn\":{\"default\":\"\",\"description\":\"iqn is the target iSCSI Qualified Name.\",\"type\":\"string\"},\"iscsiInterface\":{\"default\":\"default\",\"description\":\"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).\",\"type\":\"string\"},\"lun\":{\"default\":0,\"description\":\"lun represents iSCSI Target Lun number.\",\"format\":\"int32\",\"type\":\"integer\"},\"portals\":{\"description\":\"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"targetPortal\":{\"default\":\"\",\"description\":\"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).\",\"type\":\"string\"}},\"required\":[\"targetPortal\",\"iqn\",\"lun\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ImageVolumeSource\":{\"description\":\"ImageVolumeSource represents a image volume resource.\",\"properties\":{\"pullPolicy\":{\"description\":\"Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.\",\"type\":\"string\"},\"reference\":{\"description\":\"Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.KeyToPath\":{\"description\":\"Maps a string key to a path within a volume.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the key to project.\",\"type\":\"string\"},\"mode\":{\"description\":\"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.\",\"type\":\"string\"}},\"required\":[\"key\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Lifecycle\":{\"description\":\"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.\",\"properties\":{\"postStart\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"preStop\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LifecycleHandler\"},\"stopSignal\":{\"description\":\"StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LifecycleHandler\":{\"description\":\"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"sleep\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SleepAction\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.LimitRange\":{\"description\":\"LimitRange sets resource usage limits for each kind of resource in a Namespace.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeSpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.LimitRangeItem\":{\"description\":\"LimitRangeItem defines a min/max usage limit for any resource that matches on kind.\",\"properties\":{\"default\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Default resource requirement limit value by resource name if resource limit is omitted.\",\"type\":\"object\"},\"defaultRequest\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"DefaultRequest is the default resource requirement request value by resource name if resource request is omitted.\",\"type\":\"object\"},\"max\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Max usage constraints on this kind by resource name.\",\"type\":\"object\"},\"maxLimitRequestRatio\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.\",\"type\":\"object\"},\"min\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Min usage constraints on this kind by resource name.\",\"type\":\"object\"},\"type\":{\"default\":\"\",\"description\":\"Type of resource that this limit applies to.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\"},\"io.k8s.api.core.v1.LimitRangeList\":{\"description\":\"LimitRangeList is a list of LimitRange items.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"LimitRangeList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.LimitRangeSpec\":{\"description\":\"LimitRangeSpec defines a min/max usage limit for resources that match on kind.\",\"properties\":{\"limits\":{\"description\":\"Limits is the list of LimitRangeItem objects that are enforced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeItem\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"limits\"],\"type\":\"object\"},\"io.k8s.api.core.v1.LinuxContainerUser\":{\"description\":\"LinuxContainerUser represents user identity information in Linux containers\",\"properties\":{\"gid\":{\"default\":0,\"description\":\"GID is the primary gid initially attached to the first process in the container\",\"format\":\"int64\",\"type\":\"integer\"},\"supplementalGroups\":{\"description\":\"SupplementalGroups are the supplemental groups initially attached to the first process in the container\",\"items\":{\"default\":0,\"format\":\"int64\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"uid\":{\"default\":0,\"description\":\"UID is the primary uid initially attached to the first process in the container\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"uid\",\"gid\"],\"type\":\"object\"},\"io.k8s.api.core.v1.LoadBalancerIngress\":{\"description\":\"LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point.\",\"properties\":{\"hostname\":{\"description\":\"Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers)\",\"type\":\"string\"},\"ip\":{\"description\":\"IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers)\",\"type\":\"string\"},\"ipMode\":{\"description\":\"IPMode specifies how the load-balancer IP behaves, and may only be specified when the ip field is specified. Setting this to \\\"VIP\\\" indicates that traffic is delivered to the node with the destination set to the load-balancer's IP and port. Setting this to \\\"Proxy\\\" indicates that traffic is delivered to the node or pod with the destination set to the node's IP and node port or the pod's IP and port. Service implementations may use this information to adjust traffic routing.\",\"type\":\"string\"},\"ports\":{\"description\":\"Ports is a list of records of service ports If used, every port defined in the service should have an entry in it\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PortStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.LoadBalancerStatus\":{\"description\":\"LoadBalancerStatus represents the status of a load-balancer.\",\"properties\":{\"ingress\":{\"description\":\"Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.LocalObjectReference\":{\"description\":\"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.LocalVolumeSource\":{\"description\":\"Local represents directly-attached storage with node affinity\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". The default value is to auto-select a filesystem if unspecified.\",\"type\":\"string\"},\"path\":{\"default\":\"\",\"description\":\"path of the full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ModifyVolumeStatus\":{\"description\":\"ModifyVolumeStatus represents the status object of ControllerModifyVolume operation\",\"properties\":{\"status\":{\"default\":\"\",\"description\":\"status is the status of the ControllerModifyVolume operation. It can be in any of following states:\\n - Pending\\n Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as\\n the specified VolumeAttributesClass not existing.\\n - InProgress\\n InProgress indicates that the volume is being modified.\\n - Infeasible\\n Infeasible indicates that the request has been rejected as invalid by the CSI driver. To\\n\\t resolve the error, a valid VolumeAttributesClass needs to be specified.\\nNote: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately.\",\"type\":\"string\"},\"targetVolumeAttributesClassName\":{\"description\":\"targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled\",\"type\":\"string\"}},\"required\":[\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NFSVolumeSource\":{\"description\":\"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"path\":{\"default\":\"\",\"description\":\"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"boolean\"},\"server\":{\"default\":\"\",\"description\":\"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs\",\"type\":\"string\"}},\"required\":[\"server\",\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Namespace\":{\"description\":\"Namespace provides a scope for Names. Use of multiple namespaces is optional.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.NamespaceCondition\":{\"description\":\"NamespaceCondition contains details about state of namespace.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Human-readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"Unique, one-word, CamelCase reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of namespace controller condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NamespaceList\":{\"description\":\"NamespaceList is a list of Namespaces.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"NamespaceList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.NamespaceSpec\":{\"description\":\"NamespaceSpec describes the attributes on a Namespace.\",\"properties\":{\"finalizers\":{\"description\":\"Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.NamespaceStatus\":{\"description\":\"NamespaceStatus is information about the current status of a Namespace.\",\"properties\":{\"conditions\":{\"description\":\"Represents the latest available observations of a namespace's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"phase\":{\"description\":\"Phase is the current lifecycle phase of the namespace. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Node\":{\"description\":\"Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd).\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.NodeAddress\":{\"description\":\"NodeAddress contains information for the node's address.\",\"properties\":{\"address\":{\"default\":\"\",\"description\":\"The node address.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Node address type, one of Hostname, ExternalIP or InternalIP.\",\"type\":\"string\"}},\"required\":[\"type\",\"address\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeAffinity\":{\"description\":\"Node affinity is a group of node affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeCondition\":{\"description\":\"NodeCondition contains condition information for a node.\",\"properties\":{\"lastHeartbeatTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Human readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"(brief) reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of node condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeConfigSource\":{\"description\":\"NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. This API is deprecated since 1.22\",\"properties\":{\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeConfigStatus\":{\"description\":\"NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource.\",\"properties\":{\"active\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeConfigSource\"},\"assigned\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeConfigSource\"},\"error\":{\"description\":\"Error describes any problems reconciling the Spec.ConfigSource to the Active config. Errors may occur, for example, attempting to checkpoint Spec.ConfigSource to the local Assigned record, attempting to checkpoint the payload associated with Spec.ConfigSource, attempting to load or validate the Assigned config, etc. Errors may occur at different points while syncing config. Earlier errors (e.g. download or checkpointing errors) will not result in a rollback to LastKnownGood, and may resolve across Kubelet retries. Later errors (e.g. loading or validating a checkpointed config) will result in a rollback to LastKnownGood. In the latter case, it is usually possible to resolve the error by fixing the config assigned in Spec.ConfigSource. You can find additional information for debugging by searching the error message in the Kubelet log. Error is a human-readable description of the error state; machines can check whether or not Error is empty, but should not rely on the stability of the Error text across Kubelet versions.\",\"type\":\"string\"},\"lastKnownGood\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeConfigSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeDaemonEndpoints\":{\"description\":\"NodeDaemonEndpoints lists ports opened by daemons running on the Node.\",\"properties\":{\"kubeletEndpoint\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.DaemonEndpoint\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeFeatures\":{\"description\":\"NodeFeatures describes the set of features implemented by the CRI implementation. The features contained in the NodeFeatures should depend only on the cri implementation independent of runtime handlers.\",\"properties\":{\"supplementalGroupsPolicy\":{\"description\":\"SupplementalGroupsPolicy is set to true if the runtime supports SupplementalGroupsPolicy and ContainerUser.\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeList\":{\"description\":\"NodeList is the whole list of all Nodes which have been registered with master.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of nodes\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"NodeList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.NodeRuntimeHandler\":{\"description\":\"NodeRuntimeHandler is a set of runtime handler information.\",\"properties\":{\"features\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures\"},\"name\":{\"default\":\"\",\"description\":\"Runtime handler name. Empty for the default runtime handler.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeRuntimeHandlerFeatures\":{\"description\":\"NodeRuntimeHandlerFeatures is a set of features implemented by the runtime handler.\",\"properties\":{\"recursiveReadOnlyMounts\":{\"description\":\"RecursiveReadOnlyMounts is set to true if the runtime handler supports RecursiveReadOnlyMounts.\",\"type\":\"boolean\"},\"userNamespaces\":{\"description\":\"UserNamespaces is set to true if the runtime handler supports UserNamespaces, including for volumes.\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelector\":{\"description\":\"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.\",\"properties\":{\"nodeSelectorTerms\":{\"description\":\"Required. A list of node selector terms. The terms are ORed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"nodeSelectorTerms\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NodeSelectorRequirement\":{\"description\":\"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSelectorTerm\":{\"description\":\"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\",\"properties\":{\"matchExpressions\":{\"description\":\"A list of node selector requirements by node's labels.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchFields\":{\"description\":\"A list of node selector requirements by node's fields.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.NodeSpec\":{\"description\":\"NodeSpec describes the attributes that a node is created with.\",\"properties\":{\"configSource\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeConfigSource\"},\"externalID\":{\"description\":\"Deprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966\",\"type\":\"string\"},\"podCIDR\":{\"description\":\"PodCIDR represents the pod IP range assigned to the node.\",\"type\":\"string\"},\"podCIDRs\":{\"description\":\"podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"providerID\":{\"description\":\"ID of the node assigned by the cloud provider in the format: ://\",\"type\":\"string\"},\"taints\":{\"description\":\"If specified, the node's taints.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Taint\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"unschedulable\":{\"description\":\"Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeStatus\":{\"description\":\"NodeStatus is information about the current status of a node.\",\"properties\":{\"addresses\":{\"description\":\"List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/reference/node/node-status/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. Consumers should assume that addresses can change during the lifetime of a Node. However, there are some exceptions where this may not be possible, such as Pods that inherit a Node's address in its own status or consumers of the downward API (status.hostIP).\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeAddress\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"allocatable\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity.\",\"type\":\"object\"},\"capacity\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/reference/node/node-status/#capacity\",\"type\":\"object\"},\"conditions\":{\"description\":\"Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/reference/node/node-status/#condition\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"config\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeConfigStatus\"},\"daemonEndpoints\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints\"},\"declaredFeatures\":{\"description\":\"DeclaredFeatures represents the features related to feature gates that are declared by the node.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"features\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeFeatures\"},\"images\":{\"description\":\"List of container images on this node\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerImage\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"nodeInfo\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSystemInfo\"},\"phase\":{\"description\":\"NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated.\",\"type\":\"string\"},\"runtimeHandlers\":{\"description\":\"The available runtime handlers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"volumesAttached\":{\"description\":\"List of volumes that are attached to the node.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AttachedVolume\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"volumesInUse\":{\"description\":\"List of attachable volumes in use (mounted) by the node.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSwapStatus\":{\"description\":\"NodeSwapStatus represents swap memory information.\",\"properties\":{\"capacity\":{\"description\":\"Total amount of swap memory in bytes.\",\"format\":\"int64\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.NodeSystemInfo\":{\"description\":\"NodeSystemInfo is a set of ids/uuids to uniquely identify the node.\",\"properties\":{\"architecture\":{\"default\":\"\",\"description\":\"The Architecture reported by the node\",\"type\":\"string\"},\"bootID\":{\"default\":\"\",\"description\":\"Boot ID reported by the node.\",\"type\":\"string\"},\"containerRuntimeVersion\":{\"default\":\"\",\"description\":\"ContainerRuntime Version reported by the node through runtime remote API (e.g. containerd://1.4.2).\",\"type\":\"string\"},\"kernelVersion\":{\"default\":\"\",\"description\":\"Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64).\",\"type\":\"string\"},\"kubeProxyVersion\":{\"default\":\"\",\"description\":\"Deprecated: KubeProxy Version reported by the node.\",\"type\":\"string\"},\"kubeletVersion\":{\"default\":\"\",\"description\":\"Kubelet Version reported by the node.\",\"type\":\"string\"},\"machineID\":{\"default\":\"\",\"description\":\"MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html\",\"type\":\"string\"},\"operatingSystem\":{\"default\":\"\",\"description\":\"The Operating System reported by the node\",\"type\":\"string\"},\"osImage\":{\"default\":\"\",\"description\":\"OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).\",\"type\":\"string\"},\"swap\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSwapStatus\"},\"systemUUID\":{\"default\":\"\",\"description\":\"SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid\",\"type\":\"string\"}},\"required\":[\"machineID\",\"systemUUID\",\"bootID\",\"kernelVersion\",\"osImage\",\"containerRuntimeVersion\",\"kubeletVersion\",\"kubeProxyVersion\",\"operatingSystem\",\"architecture\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ObjectFieldSelector\":{\"description\":\"ObjectFieldSelector selects an APIVersioned field of an object.\",\"properties\":{\"apiVersion\":{\"description\":\"Version of the schema the FieldPath is written in terms of, defaults to \\\"v1\\\".\",\"type\":\"string\"},\"fieldPath\":{\"default\":\"\",\"description\":\"Path of the field to select in the specified API version.\",\"type\":\"string\"}},\"required\":[\"fieldPath\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ObjectReference\":{\"description\":\"ObjectReference contains enough information to let you inspect or modify the referred object.\",\"properties\":{\"apiVersion\":{\"description\":\"API version of the referent.\",\"type\":\"string\"},\"fieldPath\":{\"description\":\"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \\\"spec.containers{name}\\\" (where \\\"name\\\" refers to the name of the container that triggered the event) or if no container name is specified \\\"spec.containers[2]\\\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/\",\"type\":\"string\"},\"resourceVersion\":{\"description\":\"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"uid\":{\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.PersistentVolume\":{\"description\":\"PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PersistentVolumeClaim\":{\"description\":\"PersistentVolumeClaim is a user's request for and claim to a persistent volume\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PersistentVolumeClaimCondition\":{\"description\":\"PersistentVolumeClaimCondition contains details about state of pvc\",\"properties\":{\"lastProbeTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message is the human-readable message indicating details about last transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \\\"Resizing\\\" that means the underlying persistent volume is being resized.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type is the type of the condition. More info: https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimList\":{\"description\":\"PersistentVolumeClaimList is a list of PersistentVolumeClaim items.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PersistentVolumeClaimList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PersistentVolumeClaimSpec\":{\"description\":\"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"dataSource\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference\"},\"dataSourceRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.TypedObjectReference\"},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements\"},\"selector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"storageClassName\":{\"description\":\"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1\",\"type\":\"string\"},\"volumeAttributesClassName\":{\"description\":\"volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\",\"type\":\"string\"},\"volumeMode\":{\"description\":\"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the binding reference to the PersistentVolume backing this claim.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimStatus\":{\"description\":\"PersistentVolumeClaimStatus is the current status of a persistent volume claim.\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"allocatedResourceStatuses\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"allocatedResourceStatuses stores status of resource being resized for the given PVC. Key names follow standard Kubernetes label syntax. Valid values are either:\\n\\t* Un-prefixed keys:\\n\\t\\t- storage - the capacity of the volume.\\n\\t* Custom resources must use implementation-defined prefixed names such as \\\"example.com/my-custom-resource\\\"\\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\\n\\nClaimResourceStatus can be in any of following states:\\n\\t- ControllerResizeInProgress:\\n\\t\\tState set when resize controller starts resizing the volume in control-plane.\\n\\t- ControllerResizeFailed:\\n\\t\\tState set when resize has failed in resize controller with a terminal error.\\n\\t- NodeResizePending:\\n\\t\\tState set when resize controller has finished resizing the volume but further resizing of\\n\\t\\tvolume is needed on the node.\\n\\t- NodeResizeInProgress:\\n\\t\\tState set when kubelet starts resizing the volume.\\n\\t- NodeResizeFailed:\\n\\t\\tState set when resizing has failed in kubelet with a terminal error. Transient errors don't set\\n\\t\\tNodeResizeFailed.\\nFor example: if expanding a PVC for more capacity - this field can be one of the following states:\\n\\t- pvc.status.allocatedResourceStatus['storage'] = \\\"ControllerResizeInProgress\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"ControllerResizeFailed\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizePending\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizeInProgress\\\"\\n - pvc.status.allocatedResourceStatus['storage'] = \\\"NodeResizeFailed\\\"\\nWhen this field is not set, it means that no resize operation is in progress for the given PVC.\\n\\nA controller that receives PVC update with previously unknown resourceName or ClaimResourceStatus should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.\",\"type\":\"object\",\"x-kubernetes-map-type\":\"granular\"},\"allocatedResources\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"allocatedResources tracks the resources allocated to a PVC including its capacity. Key names follow standard Kubernetes label syntax. Valid values are either:\\n\\t* Un-prefixed keys:\\n\\t\\t- storage - the capacity of the volume.\\n\\t* Custom resources must use implementation-defined prefixed names such as \\\"example.com/my-custom-resource\\\"\\nApart from above values - keys that are unprefixed or have kubernetes.io prefix are considered reserved and hence may not be used.\\n\\nCapacity reported here may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity.\\n\\nA controller that receives PVC update with previously unknown resourceName should ignore the update for the purpose it was designed. For example - a controller that only is responsible for resizing capacity of the volume, should ignore PVC updates that change other valid resources associated with PVC.\",\"type\":\"object\"},\"capacity\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"capacity represents the actual resources of the underlying volume.\",\"type\":\"object\"},\"conditions\":{\"description\":\"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'Resizing'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"currentVolumeAttributesClassName\":{\"description\":\"currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim\",\"type\":\"string\"},\"modifyVolumeStatus\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus\"},\"phase\":{\"description\":\"phase represents the current phase of PersistentVolumeClaim.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimTemplate\":{\"description\":\"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec\"}},\"required\":[\"spec\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\":{\"description\":\"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).\",\"properties\":{\"claimName\":{\"default\":\"\",\"description\":\"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.\",\"type\":\"boolean\"}},\"required\":[\"claimName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeList\":{\"description\":\"PersistentVolumeList is a list of PersistentVolume items.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"items is a list of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PersistentVolumeList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PersistentVolumeSpec\":{\"description\":\"PersistentVolumeSpec is the specification of a persistent volume.\",\"properties\":{\"accessModes\":{\"description\":\"accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"awsElasticBlockStore\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\"},\"azureDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource\"},\"azureFile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource\"},\"capacity\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity\",\"type\":\"object\"},\"cephfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource\"},\"cinder\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource\"},\"claimRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"csi\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource\"},\"fc\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FCVolumeSource\"},\"flexVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource\"},\"flocker\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource\"},\"gcePersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\"},\"glusterfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource\"},\"hostPath\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource\"},\"iscsi\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource\"},\"local\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalVolumeSource\"},\"mountOptions\":{\"description\":\"mountOptions is the list of mount options, e.g. [\\\"ro\\\", \\\"soft\\\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"nfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource\"},\"nodeAffinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity\"},\"persistentVolumeReclaimPolicy\":{\"description\":\"persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming\",\"type\":\"string\"},\"photonPersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\"},\"portworxVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource\"},\"quobyte\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource\"},\"rbd\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource\"},\"scaleIO\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource\"},\"storageClassName\":{\"description\":\"storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass.\",\"type\":\"string\"},\"storageos\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource\"},\"volumeAttributesClassName\":{\"description\":\"Name of VolumeAttributesClass to which this persistent volume belongs. Empty value is not allowed. When this field is not set, it indicates that this volume does not belong to any VolumeAttributesClass. This field is mutable and can be changed by the CSI driver after a volume has been updated successfully to a new class. For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound PersistentVolumeClaims during the binding process.\",\"type\":\"string\"},\"volumeMode\":{\"description\":\"volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec.\",\"type\":\"string\"},\"vsphereVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PersistentVolumeStatus\":{\"description\":\"PersistentVolumeStatus is the current status of a persistent volume.\",\"properties\":{\"lastPhaseTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"message is a human-readable message indicating details about why the volume is in this state.\",\"type\":\"string\"},\"phase\":{\"description\":\"phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase\",\"type\":\"string\"},\"reason\":{\"description\":\"reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\":{\"description\":\"Represents a Photon Controller persistent disk resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"pdID\":{\"default\":\"\",\"description\":\"pdID is the ID that identifies Photon Controller persistent disk\",\"type\":\"string\"}},\"required\":[\"pdID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Pod\":{\"description\":\"Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PodAffinity\":{\"description\":\"Pod affinity is a group of inter pod affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \\\"weight\\\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodAffinityTerm\":{\"description\":\"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"mismatchLabelKeys\":{\"description\":\"MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"namespaceSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"namespaces\":{\"description\":\"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \\\"this pod's namespace\\\".\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologyKey\":{\"default\":\"\",\"description\":\"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\",\"type\":\"string\"}},\"required\":[\"topologyKey\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodAntiAffinity\":{\"description\":\"Pod anti affinity is a group of inter pod anti affinity scheduling rules.\",\"properties\":{\"preferredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and subtracting \\\"weight\\\" from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"requiredDuringSchedulingIgnoredDuringExecution\":{\"description\":\"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodCertificateProjection\":{\"description\":\"PodCertificateProjection provides a private key and X.509 certificate in the pod filesystem.\",\"properties\":{\"certificateChainPath\":{\"description\":\"Write the certificate chain at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"credentialBundlePath\":{\"description\":\"Write the credential bundle at this path in the projected volume.\\n\\nThe credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key.\\n\\nThe remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates).\\n\\nUsing credentialBundlePath lets your Pod's application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key.\",\"type\":\"string\"},\"keyPath\":{\"description\":\"Write the key at this path in the projected volume.\\n\\nMost applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation.\",\"type\":\"string\"},\"keyType\":{\"description\":\"The type of keypair Kubelet will generate for the pod.\\n\\nValid values are \\\"RSA3072\\\", \\\"RSA4096\\\", \\\"ECDSAP256\\\", \\\"ECDSAP384\\\", \\\"ECDSAP521\\\", and \\\"ED25519\\\".\",\"type\":\"string\"},\"maxExpirationSeconds\":{\"description\":\"maxExpirationSeconds is the maximum lifetime permitted for the certificate.\\n\\nKubelet copies this value verbatim into the PodCertificateRequests it generates for this projection.\\n\\nIf omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days).\\n\\nThe signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. `kubernetes.io` signers will never issue certificates with a lifetime longer than 24 hours.\",\"format\":\"int32\",\"type\":\"integer\"},\"signerName\":{\"description\":\"Kubelet's generated CSRs will be addressed to this signer.\",\"type\":\"string\"},\"userAnnotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way.\\n\\nThese values are copied verbatim into the `spec.unverifiedUserAnnotations` field of the PodCertificateRequest objects that Kubelet creates.\\n\\nEntries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field.\\n\\nSigners should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.\",\"type\":\"object\"}},\"required\":[\"signerName\",\"keyType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodCondition\":{\"description\":\"PodCondition contains details for the current condition of this pod.\",\"properties\":{\"lastProbeTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"Human-readable message indicating details about last transition.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"If set, this represents the .metadata.generation that the pod condition was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.\",\"format\":\"int64\",\"type\":\"integer\"},\"reason\":{\"description\":\"Unique, one-word, CamelCase reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfig\":{\"description\":\"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.\",\"properties\":{\"nameservers\":{\"description\":\"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"options\":{\"description\":\"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"searches\":{\"description\":\"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodDNSConfigOption\":{\"description\":\"PodDNSConfigOption defines DNS resolver options of a pod.\",\"properties\":{\"name\":{\"description\":\"Name is this DNS resolver option's name. Required.\",\"type\":\"string\"},\"value\":{\"description\":\"Value is this DNS resolver option's value.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodExtendedResourceClaimStatus\":{\"description\":\"PodExtendedResourceClaimStatus is stored in the PodStatus for the extended resource requests backed by DRA. It stores the generated name for the corresponding special ResourceClaim created by the scheduler.\",\"properties\":{\"requestMappings\":{\"description\":\"RequestMappings identifies the mapping of to device request in the generated ResourceClaim.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resourceClaimName\":{\"default\":\"\",\"description\":\"ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod.\",\"type\":\"string\"}},\"required\":[\"requestMappings\",\"resourceClaimName\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodIP\":{\"description\":\"PodIP represents a single IP address allocated to the pod.\",\"properties\":{\"ip\":{\"default\":\"\",\"description\":\"IP is the IP address assigned to the pod\",\"type\":\"string\"}},\"required\":[\"ip\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodList\":{\"description\":\"PodList is a list of Pods.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of pods. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PodList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PodOS\":{\"description\":\"PodOS defines the OS parameters of a pod.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodReadinessGate\":{\"description\":\"PodReadinessGate contains the reference to a pod condition\",\"properties\":{\"conditionType\":{\"default\":\"\",\"description\":\"ConditionType refers to a condition in the pod's condition list with matching type.\",\"type\":\"string\"}},\"required\":[\"conditionType\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodResourceClaim\":{\"description\":\"PodResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the pod.\\n\\nIt adds a name to it that uniquely identifies the ResourceClaim inside the Pod. Containers that need access to the ResourceClaim reference it with this name.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL.\",\"type\":\"string\"},\"resourceClaimName\":{\"description\":\"ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"},\"resourceClaimTemplateName\":{\"description\":\"ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod.\\n\\nThe template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The pod name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses.\\n\\nThis field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.\\n\\nExactly one of ResourceClaimName and ResourceClaimTemplateName must be set.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodResourceClaimStatus\":{\"description\":\"PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name uniquely identifies this resource claim inside the pod. This must match the name of an entry in pod.spec.resourceClaims, which implies that the string must be a DNS_LABEL.\",\"type\":\"string\"},\"resourceClaimName\":{\"description\":\"ResourceClaimName is the name of the ResourceClaim that was generated for the Pod in the namespace of the Pod. If this is unset, then generating a ResourceClaim was not necessary. The pod.spec.resourceClaims entry can be ignored in this case.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSchedulingGate\":{\"description\":\"PodSchedulingGate is associated to a Pod to guard its scheduling.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the scheduling gate. Each scheduling gate must have a unique name field.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodSecurityContext\":{\"description\":\"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.\",\"properties\":{\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"fsGroup\":{\"description\":\"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\\n\\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw----\\n\\nIf unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"fsGroupChangePolicy\":{\"description\":\"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \\\"OnRootMismatch\\\" and \\\"Always\\\". If not specified, \\\"Always\\\" is used. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxChangePolicy\":{\"description\":\"seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod. It has no effect on nodes that do not support SELinux or to volumes does not support SELinux. Valid values are \\\"MountOption\\\" and \\\"Recursive\\\".\\n\\n\\\"Recursive\\\" means relabeling of all files on all Pod volumes by the container runtime. This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.\\n\\n\\\"MountOption\\\" mounts all eligible Pod volumes with `-o context` mount option. This requires all Pods that share the same volume to use the same SELinux label. It is not possible to share the same volume among privileged and unprivileged Pods. Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their CSIDriver instance. Other volumes are always re-labelled recursively. \\\"MountOption\\\" value is allowed only when SELinuxMount feature gate is enabled.\\n\\nIf not specified and SELinuxMount feature gate is enabled, \\\"MountOption\\\" is used. If not specified and SELinuxMount feature gate is disabled, \\\"MountOption\\\" is used for ReadWriteOncePod volumes and \\\"Recursive\\\" for all other volumes.\\n\\nThis field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.\\n\\nAll Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"supplementalGroups\":{\"description\":\"A list of groups applied to the first process run in each container, in addition to the container's primary GID and fsGroup (if specified). If the SupplementalGroupsPolicy feature is enabled, the supplementalGroupsPolicy field determines whether these are in addition to or instead of any group memberships defined in the container image. If unspecified, no additional groups are added, though group memberships defined in the container image may still be used, depending on the supplementalGroupsPolicy field. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"default\":0,\"format\":\"int64\",\"type\":\"integer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"supplementalGroupsPolicy\":{\"description\":\"Defines how supplemental groups of the first container processes are calculated. Valid values are \\\"Merge\\\" and \\\"Strict\\\". If not specified, \\\"Merge\\\" is used. (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled and the container runtime must implement support for this feature. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"sysctls\":{\"description\":\"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Sysctl\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodSpec\":{\"description\":\"PodSpec is a description of a pod.\",\"properties\":{\"activeDeadlineSeconds\":{\"description\":\"Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.\",\"format\":\"int64\",\"type\":\"integer\"},\"affinity\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Affinity\"},\"automountServiceAccountToken\":{\"description\":\"AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.\",\"type\":\"boolean\"},\"containers\":{\"description\":\"List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"dnsConfig\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodDNSConfig\"},\"dnsPolicy\":{\"description\":\"Set DNS policy for the pod. Defaults to \\\"ClusterFirst\\\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.\",\"type\":\"string\"},\"enableServiceLinks\":{\"description\":\"EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.\",\"type\":\"boolean\"},\"ephemeralContainers\":{\"description\":\"List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EphemeralContainer\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostAliases\":{\"description\":\"HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HostAlias\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"ip\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"ip\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"hostIPC\":{\"description\":\"Use the host's ipc namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostNetwork\":{\"description\":\"Host networking requested for this pod. Use the host's network namespace. When using HostNetwork you should specify ports so the scheduler is aware. When `hostNetwork` is true, specified `hostPort` fields in port definitions must match `containerPort`, and unspecified `hostPort` fields in port definitions are defaulted to match `containerPort`. Default to false.\",\"type\":\"boolean\"},\"hostPID\":{\"description\":\"Use the host's pid namespace. Optional: Default to false.\",\"type\":\"boolean\"},\"hostUsers\":{\"description\":\"Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.\",\"type\":\"boolean\"},\"hostname\":{\"description\":\"Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.\",\"type\":\"string\"},\"hostnameOverride\":{\"description\":\"HostnameOverride specifies an explicit override for the pod's hostname as perceived by the pod. This field only specifies the pod's hostname and does not affect its DNS records. When this field is set to a non-empty string: - It takes precedence over the values set in `hostname` and `subdomain`. - The Pod's hostname will be set to this value. - `setHostnameAsFQDN` must be nil or set to false. - `hostNetwork` must be set to false.\\n\\nThis field must be a valid DNS subdomain as defined in RFC 1123 and contain at most 64 characters. Requires the HostnameOverride feature gate to be enabled.\",\"type\":\"string\"},\"imagePullSecrets\":{\"description\":\"ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"initContainers\":{\"description\":\"List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Container\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"nodeName\":{\"description\":\"NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename\",\"type\":\"string\"},\"nodeSelector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"os\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodOS\"},\"overhead\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md\",\"type\":\"object\"},\"preemptionPolicy\":{\"description\":\"PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset.\",\"type\":\"string\"},\"priority\":{\"description\":\"The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.\",\"format\":\"int32\",\"type\":\"integer\"},\"priorityClassName\":{\"description\":\"If specified, indicates the pod's priority. \\\"system-node-critical\\\" and \\\"system-cluster-critical\\\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.\",\"type\":\"string\"},\"readinessGates\":{\"description\":\"If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \\\"True\\\" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodReadinessGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"resourceClaims\":{\"description\":\"ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name.\\n\\nThis is a stable field but requires that the DynamicResourceAllocation feature gate is enabled.\\n\\nThis field is immutable.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"restartPolicy\":{\"description\":\"Restart policy for all containers within the pod. One of Always, OnFailure, Never. In some contexts, only a subset of those values may be permitted. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy\",\"type\":\"string\"},\"runtimeClassName\":{\"description\":\"RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \\\"legacy\\\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class\",\"type\":\"string\"},\"schedulerName\":{\"description\":\"If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.\",\"type\":\"string\"},\"schedulingGates\":{\"description\":\"SchedulingGates is an opaque list of values that if specified will block scheduling the pod. If schedulingGates is not empty, the pod will stay in the SchedulingGated state and the scheduler will not attempt to schedule the pod.\\n\\nSchedulingGates can only be set at pod creation time, and be removed only afterwards.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"securityContext\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodSecurityContext\"},\"serviceAccount\":{\"description\":\"DeprecatedServiceAccount is a deprecated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.\",\"type\":\"string\"},\"serviceAccountName\":{\"description\":\"ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/\",\"type\":\"string\"},\"setHostnameAsFQDN\":{\"description\":\"If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\\\\\\\SYSTEM\\\\\\\\CurrentControlSet\\\\\\\\Services\\\\\\\\Tcpip\\\\\\\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.\",\"type\":\"boolean\"},\"shareProcessNamespace\":{\"description\":\"Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.\",\"type\":\"boolean\"},\"subdomain\":{\"description\":\"If specified, the fully qualified Pod hostname will be \\\"...svc.\\\". If not specified, the pod will not have a domainname at all.\",\"type\":\"string\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.\",\"format\":\"int64\",\"type\":\"integer\"},\"tolerations\":{\"description\":\"If specified, the pod's tolerations.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Toleration\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"topologySpreadConstraints\":{\"description\":\"TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"topologyKey\",\"whenUnsatisfiable\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"topologyKey\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"volumes\":{\"description\":\"List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Volume\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"workloadRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.WorkloadReference\"}},\"required\":[\"containers\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PodStatus\":{\"description\":\"PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane.\",\"properties\":{\"allocatedResources\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"AllocatedResources is the total requests allocated for this pod by the node. If pod-level requests are not set, this will be the total requests aggregated across containers in the pod.\",\"type\":\"object\"},\"conditions\":{\"description\":\"Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"containerStatuses\":{\"description\":\"Statuses of containers in this pod. Each container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ephemeralContainerStatuses\":{\"description\":\"Statuses for any ephemeral containers that have run in this pod. Each ephemeral container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"extendedResourceClaimStatus\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus\"},\"hostIP\":{\"description\":\"hostIP holds the IP address of the host to which the pod is assigned. Empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns mean that HostIP will not be updated even if there is a node is assigned to pod\",\"type\":\"string\"},\"hostIPs\":{\"description\":\"hostIPs holds the IP addresses allocated to the host. If this field is specified, the first entry must match the hostIP field. This list is empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns means that HostIPs will not be updated even if there is a node is assigned to this pod.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HostIP\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"x-kubernetes-patch-merge-key\":\"ip\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"initContainerStatuses\":{\"description\":\"Statuses of init containers in this pod. The most recent successful non-restartable init container will have ready = true, the most recently started container will have startTime set. Each init container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-and-container-status\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ContainerStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"message\":{\"description\":\"A human readable message indicating details about why the pod is in this condition.\",\"type\":\"string\"},\"nominatedNodeName\":{\"description\":\"nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"If set, this represents the .metadata.generation that the pod status was set based upon. The PodObservedGenerationTracking feature gate must be enabled to use this field.\",\"format\":\"int64\",\"type\":\"integer\"},\"phase\":{\"description\":\"The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:\\n\\nPending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod.\\n\\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase\",\"type\":\"string\"},\"podIP\":{\"description\":\"podIP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.\",\"type\":\"string\"},\"podIPs\":{\"description\":\"podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodIP\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"ip\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"ip\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"qosClass\":{\"description\":\"The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/#quality-of-service-classes\",\"type\":\"string\"},\"reason\":{\"description\":\"A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted'\",\"type\":\"string\"},\"resize\":{\"description\":\"Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to \\\"Proposed\\\" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.\",\"type\":\"string\"},\"resourceClaimStatuses\":{\"description\":\"Status of resource claims.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge,retainKeys\",\"nullable\":true},\"resources\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceRequirements\"},\"startTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PodTemplate\":{\"description\":\"PodTemplate describes a template for creating copies of a predefined pod.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PodTemplateList\":{\"description\":\"PodTemplateList is a list of PodTemplates.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of pod templates\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"PodTemplateList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.PodTemplateSpec\":{\"description\":\"PodTemplateSpec describes the data a pod should have when created from a template\",\"properties\":{\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodSpec\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.PortStatus\":{\"description\":\"PortStatus represents the error condition of a service port\",\"properties\":{\"error\":{\"description\":\"Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use\\n CamelCase names\\n- cloud provider specific error values must have names that comply with the\\n format foo.example.com/CamelCase.\",\"type\":\"string\"},\"port\":{\"default\":0,\"description\":\"Port is the port number of the service port of which status is recorded here\",\"format\":\"int32\",\"type\":\"integer\"},\"protocol\":{\"default\":\"\",\"description\":\"Protocol is the protocol of the service port of which status is recorded here The supported values are: \\\"TCP\\\", \\\"UDP\\\", \\\"SCTP\\\"\",\"type\":\"string\"}},\"required\":[\"port\",\"protocol\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PortworxVolumeSource\":{\"description\":\"PortworxVolumeSource represents a Portworx volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"volumeID\":{\"default\":\"\",\"description\":\"volumeID uniquely identifies a Portworx volume\",\"type\":\"string\"}},\"required\":[\"volumeID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.PreferredSchedulingTerm\":{\"description\":\"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\",\"properties\":{\"preference\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm\"},\"weight\":{\"default\":0,\"description\":\"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"preference\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Probe\":{\"description\":\"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.\",\"properties\":{\"exec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ExecAction\"},\"failureThreshold\":{\"description\":\"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"grpc\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GRPCAction\"},\"httpGet\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HTTPGetAction\"},\"initialDelaySeconds\":{\"description\":\"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"},\"periodSeconds\":{\"description\":\"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"successThreshold\":{\"description\":\"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.\",\"format\":\"int32\",\"type\":\"integer\"},\"tcpSocket\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.TCPSocketAction\"},\"terminationGracePeriodSeconds\":{\"description\":\"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.\",\"format\":\"int64\",\"type\":\"integer\"},\"timeoutSeconds\":{\"description\":\"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\",\"format\":\"int32\",\"type\":\"integer\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ProjectedVolumeSource\":{\"description\":\"Represents a projected volume source\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"sources\":{\"description\":\"sources is the list of volume projections. Each entry in this list handles one source.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VolumeProjection\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.QuobyteVolumeSource\":{\"description\":\"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.\",\"properties\":{\"group\":{\"description\":\"group to map volume access to Default is no group\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.\",\"type\":\"boolean\"},\"registry\":{\"default\":\"\",\"description\":\"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes\",\"type\":\"string\"},\"tenant\":{\"description\":\"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin\",\"type\":\"string\"},\"user\":{\"description\":\"user to map volume access to Defaults to serivceaccount user\",\"type\":\"string\"},\"volume\":{\"default\":\"\",\"description\":\"volume is a string that references an already created Quobyte volume by name.\",\"type\":\"string\"}},\"required\":[\"registry\",\"volume\"],\"type\":\"object\"},\"io.k8s.api.core.v1.RBDPersistentVolumeSource\":{\"description\":\"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"keyring\":{\"default\":\"/etc/ceph/keyring\",\"description\":\"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"monitors\":{\"description\":\"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pool\":{\"default\":\"rbd\",\"description\":\"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"user\":{\"default\":\"admin\",\"description\":\"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\",\"image\"],\"type\":\"object\"},\"io.k8s.api.core.v1.RBDVolumeSource\":{\"description\":\"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd\",\"type\":\"string\"},\"image\":{\"default\":\"\",\"description\":\"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"keyring\":{\"default\":\"/etc/ceph/keyring\",\"description\":\"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"monitors\":{\"description\":\"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"pool\":{\"default\":\"rbd\",\"description\":\"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"user\":{\"default\":\"admin\",\"description\":\"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it\",\"type\":\"string\"}},\"required\":[\"monitors\",\"image\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ReplicationController\":{\"description\":\"ReplicationController represents the configuration of a replication controller.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ReplicationControllerCondition\":{\"description\":\"ReplicationControllerCondition describes the state of a replication controller at a certain point.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"description\":\"A human readable message indicating details about the transition.\",\"type\":\"string\"},\"reason\":{\"description\":\"The reason for the condition's last transition.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"Status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"Type of replication controller condition.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ReplicationControllerList\":{\"description\":\"ReplicationControllerList is a collection of replication controllers.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ReplicationControllerList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ReplicationControllerSpec\":{\"description\":\"ReplicationControllerSpec is the specification of a replication controller.\",\"properties\":{\"minReadySeconds\":{\"default\":0,\"description\":\"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"default\":1,\"description\":\"Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller\",\"format\":\"int32\",\"type\":\"integer\"},\"selector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"template\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateSpec\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ReplicationControllerStatus\":{\"description\":\"ReplicationControllerStatus represents the current status of a replication controller.\",\"properties\":{\"availableReplicas\":{\"description\":\"The number of available replicas (ready for at least minReadySeconds) for this replication controller.\",\"format\":\"int32\",\"type\":\"integer\"},\"conditions\":{\"description\":\"Represents the latest available observations of a replication controller's current state.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"fullyLabeledReplicas\":{\"description\":\"The number of pods that have labels matching the labels of the pod template of the replication controller.\",\"format\":\"int32\",\"type\":\"integer\"},\"observedGeneration\":{\"description\":\"ObservedGeneration reflects the generation of the most recently observed replication controller.\",\"format\":\"int64\",\"type\":\"integer\"},\"readyReplicas\":{\"description\":\"The number of ready replicas for this replication controller.\",\"format\":\"int32\",\"type\":\"integer\"},\"replicas\":{\"default\":0,\"description\":\"Replicas is the most recently observed number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"replicas\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceClaim\":{\"description\":\"ResourceClaim references one entry in PodSpec.ResourceClaims.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.\",\"type\":\"string\"},\"request\":{\"description\":\"Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request.\",\"type\":\"string\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceFieldSelector\":{\"description\":\"ResourceFieldSelector represents container resources (cpu, memory) and their output format\",\"properties\":{\"containerName\":{\"description\":\"Container name: required for volumes, optional for env vars\",\"type\":\"string\"},\"divisor\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"resource\":{\"default\":\"\",\"description\":\"Required: resource to select\",\"type\":\"string\"}},\"required\":[\"resource\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ResourceHealth\":{\"description\":\"ResourceHealth represents the health of a resource. It has the latest device health information. This is a part of KEP https://kep.k8s.io/4680.\",\"properties\":{\"health\":{\"description\":\"Health of the resource. can be one of:\\n - Healthy: operates as normal\\n - Unhealthy: reported unhealthy. We consider this a temporary health issue\\n since we do not have a mechanism today to distinguish\\n temporary and permanent issues.\\n - Unknown: The status cannot be determined.\\n For example, Device Plugin got unregistered and hasn't been re-registered since.\\n\\nIn future we may want to introduce the PermanentlyUnhealthy Status.\",\"type\":\"string\"},\"resourceID\":{\"default\":\"\",\"description\":\"ResourceID is the unique identifier of the resource. See the ResourceID type for more information.\",\"type\":\"string\"}},\"required\":[\"resourceID\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceQuota\":{\"description\":\"ResourceQuota sets aggregate quota restrictions enforced per namespace\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ResourceQuotaList\":{\"description\":\"ResourceQuotaList is a list of ResourceQuota items.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ResourceQuotaList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ResourceQuotaSpec\":{\"description\":\"ResourceQuotaSpec defines the desired hard limits to enforce for Quota.\",\"properties\":{\"hard\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/\",\"type\":\"object\"},\"scopeSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ScopeSelector\"},\"scopes\":{\"description\":\"A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceQuotaStatus\":{\"description\":\"ResourceQuotaStatus defines the enforced hard limits and observed use.\",\"properties\":{\"hard\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/\",\"type\":\"object\"},\"used\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Used is the current observed total usage of the resource in the namespace.\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceRequirements\":{\"description\":\"ResourceRequirements describes the compute resource requirements.\",\"properties\":{\"claims\":{\"description\":\"Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container.\\n\\nThis field depends on the DynamicResourceAllocation feature gate.\\n\\nThis field is immutable. It can only be set for containers.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceClaim\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true},\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ResourceStatus\":{\"description\":\"ResourceStatus represents the status of a single resource allocated to a Pod.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the resource. Must be unique within the pod and in case of non-DRA resource, match one of the resources from the pod spec. For DRA resources, the value must be \\\"claim:/\\\". When this status is reported about a container, the \\\"claim_name\\\" and \\\"request\\\" must match one of the claims of this container.\",\"type\":\"string\"},\"resources\":{\"description\":\"List of unique resources health. Each element in the list contains an unique resource ID and its health. At a minimum, for the lifetime of a Pod, resource ID must uniquely identify the resource allocated to the Pod on the Node. If other Pod on the same Node reports the status with the same resource ID, it must be the same resource they share. See ResourceID type definition for a specific format it has in various use cases.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceHealth\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"resourceID\"],\"x-kubernetes-list-type\":\"map\",\"nullable\":true}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SELinuxOptions\":{\"description\":\"SELinuxOptions are the labels to be applied to the container\",\"properties\":{\"level\":{\"description\":\"Level is SELinux level label that applies to the container.\",\"type\":\"string\"},\"role\":{\"description\":\"Role is a SELinux role label that applies to the container.\",\"type\":\"string\"},\"type\":{\"description\":\"Type is a SELinux type label that applies to the container.\",\"type\":\"string\"},\"user\":{\"description\":\"User is a SELinux user label that applies to the container.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ScaleIOPersistentVolumeSource\":{\"description\":\"ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume\",\"properties\":{\"fsType\":{\"default\":\"xfs\",\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Default is \\\"xfs\\\"\",\"type\":\"string\"},\"gateway\":{\"default\":\"\",\"description\":\"gateway is the host address of the ScaleIO API Gateway.\",\"type\":\"string\"},\"protectionDomain\":{\"description\":\"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretReference\"},\"sslEnabled\":{\"description\":\"sslEnabled is the flag to enable/disable SSL communication with Gateway, default false\",\"type\":\"boolean\"},\"storageMode\":{\"default\":\"ThinProvisioned\",\"description\":\"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.\",\"type\":\"string\"},\"storagePool\":{\"description\":\"storagePool is the ScaleIO Storage Pool associated with the protection domain.\",\"type\":\"string\"},\"system\":{\"default\":\"\",\"description\":\"system is the name of the storage system as configured in ScaleIO.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.\",\"type\":\"string\"}},\"required\":[\"gateway\",\"system\",\"secretRef\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ScaleIOVolumeSource\":{\"description\":\"ScaleIOVolumeSource represents a persistent ScaleIO volume\",\"properties\":{\"fsType\":{\"default\":\"xfs\",\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Default is \\\"xfs\\\".\",\"type\":\"string\"},\"gateway\":{\"default\":\"\",\"description\":\"gateway is the host address of the ScaleIO API Gateway.\",\"type\":\"string\"},\"protectionDomain\":{\"description\":\"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"sslEnabled\":{\"description\":\"sslEnabled Flag enable/disable SSL communication with Gateway, default false\",\"type\":\"boolean\"},\"storageMode\":{\"default\":\"ThinProvisioned\",\"description\":\"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.\",\"type\":\"string\"},\"storagePool\":{\"description\":\"storagePool is the ScaleIO Storage Pool associated with the protection domain.\",\"type\":\"string\"},\"system\":{\"default\":\"\",\"description\":\"system is the name of the storage system as configured in ScaleIO.\",\"type\":\"string\"},\"volumeName\":{\"description\":\"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.\",\"type\":\"string\"}},\"required\":[\"gateway\",\"system\",\"secretRef\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ScopeSelector\":{\"description\":\"A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements.\",\"properties\":{\"matchExpressions\":{\"description\":\"A list of scope selector requirements by scope of the resources.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.ScopedResourceSelectorRequirement\":{\"description\":\"A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values.\",\"properties\":{\"operator\":{\"default\":\"\",\"description\":\"Represents a scope's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist.\",\"type\":\"string\"},\"scopeName\":{\"default\":\"\",\"description\":\"The name of the scope that the selector applies to.\",\"type\":\"string\"},\"values\":{\"description\":\"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"scopeName\",\"operator\"],\"type\":\"object\"},\"io.k8s.api.core.v1.SeccompProfile\":{\"description\":\"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.\",\"properties\":{\"localhostProfile\":{\"description\":\"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must be set if type is \\\"Localhost\\\". Must NOT be set for any other type.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type indicates which kind of seccomp profile will be applied. Valid options are:\\n\\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.\",\"type\":\"string\"}},\"required\":[\"type\"],\"type\":\"object\",\"x-kubernetes-unions\":[{\"discriminator\":\"type\",\"fields-to-discriminateBy\":{\"localhostProfile\":\"LocalhostProfile\"}}]},\"io.k8s.api.core.v1.Secret\":{\"description\":\"Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"data\":{\"additionalProperties\":{\"format\":\"byte\",\"type\":\"string\"},\"description\":\"Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4\",\"type\":\"object\"},\"immutable\":{\"description\":\"Immutable, if set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"stringData\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"stringData allows specifying non-binary secret data in string form. It is provided as a write-only input field for convenience. All keys and values are merged into the data field on write, overwriting any existing values. The stringData field is never output when reading from the API.\",\"type\":\"object\"},\"type\":{\"description\":\"Used to facilitate programmatic handling of secret data. More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.SecretEnvSource\":{\"description\":\"SecretEnvSource selects a Secret to populate the environment variables with.\\n\\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretKeySelector\":{\"description\":\"SecretKeySelector selects a key of a Secret.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"The key of the secret to select from. Must be a valid secret key.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"Specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"required\":[\"key\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.SecretList\":{\"description\":\"SecretList is a list of Secret.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"Items is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"SecretList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.SecretProjection\":{\"description\":\"Adapts a secret into a projected volume.\\n\\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.\",\"properties\":{\"items\":{\"description\":\"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"optional\":{\"description\":\"optional field specify whether the Secret or its key must be defined\",\"type\":\"boolean\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecretReference\":{\"description\":\"SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace\",\"properties\":{\"name\":{\"description\":\"name is unique within a namespace to reference a secret resource.\",\"type\":\"string\"},\"namespace\":{\"description\":\"namespace defines the space within which the secret name must be unique.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.SecretVolumeSource\":{\"description\":\"Adapts a Secret into a volume.\\n\\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.\",\"properties\":{\"defaultMode\":{\"description\":\"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.\",\"format\":\"int32\",\"type\":\"integer\"},\"items\":{\"description\":\"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.KeyToPath\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"optional\":{\"description\":\"optional field specify whether the Secret or its keys must be defined\",\"type\":\"boolean\"},\"secretName\":{\"description\":\"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SecurityContext\":{\"description\":\"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.\",\"properties\":{\"allowPrivilegeEscalation\":{\"description\":\"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"appArmorProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AppArmorProfile\"},\"capabilities\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Capabilities\"},\"privileged\":{\"description\":\"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"procMount\":{\"description\":\"procMount denotes the type of proc mount to use for the containers. The default value is Default which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"string\"},\"readOnlyRootFilesystem\":{\"description\":\"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.\",\"type\":\"boolean\"},\"runAsGroup\":{\"description\":\"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"runAsNonRoot\":{\"description\":\"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"boolean\"},\"runAsUser\":{\"description\":\"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.\",\"format\":\"int64\",\"type\":\"integer\"},\"seLinuxOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SELinuxOptions\"},\"seccompProfile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SeccompProfile\"},\"windowsOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Service\":{\"description\":\"Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"spec\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceSpec\"},\"status\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceStatus\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ServiceAccount\":{\"description\":\"ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"automountServiceAccountToken\":{\"description\":\"AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level.\",\"type\":\"boolean\"},\"imagePullSecrets\":{\"description\":\"ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"},\"secrets\":{\"description\":\"Secrets is a list of the secrets in the same namespace that pods running using this ServiceAccount are allowed to use. Pods are only limited to this list if this service account has a \\\"kubernetes.io/enforce-mountable-secrets\\\" annotation set to \\\"true\\\". The \\\"kubernetes.io/enforce-mountable-secrets\\\" annotation is deprecated since v1.32. Prefer separate namespaces to isolate access to mounted secrets. This field should not be used to find auto-generated service account token secrets for use outside of pods. Instead, tokens can be requested directly using the TokenRequest API, or service account token secrets can be manually created. More info: https://kubernetes.io/docs/concepts/configuration/secret\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"name\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"name\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ServiceAccountList\":{\"description\":\"ServiceAccountList is a list of ServiceAccount objects\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ServiceAccountList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ServiceAccountTokenProjection\":{\"description\":\"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).\",\"properties\":{\"audience\":{\"description\":\"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.\",\"type\":\"string\"},\"expirationSeconds\":{\"description\":\"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.\",\"format\":\"int64\",\"type\":\"integer\"},\"path\":{\"default\":\"\",\"description\":\"path is the path relative to the mount point of the file to project the token into.\",\"type\":\"string\"}},\"required\":[\"path\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ServiceList\":{\"description\":\"ServiceList holds a list of services.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"items\":{\"description\":\"List of services\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"}},\"required\":[\"items\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"ServiceList\",\"version\":\"v1\"}]},\"io.k8s.api.core.v1.ServicePort\":{\"description\":\"ServicePort contains information on service's port.\",\"properties\":{\"appProtocol\":{\"description\":\"The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:\\n\\n* Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).\\n\\n* Kubernetes-defined prefixed names:\\n * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-\\n * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455\\n * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455\\n\\n* Other protocols should use implementation-defined prefixed names such as mycompany.com/my-custom-protocol.\",\"type\":\"string\"},\"name\":{\"description\":\"The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. When considering the endpoints for a Service, this must match the 'name' field in the EndpointPort. Optional if only one ServicePort is defined on this service.\",\"type\":\"string\"},\"nodePort\":{\"description\":\"The port on each node on which this service is exposed when type is NodePort or LoadBalancer. Usually assigned by the system. If a value is specified, in-range, and not in use it will be used, otherwise the operation will fail. If not specified, a port will be allocated if this Service requires one. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type from NodePort to ClusterIP). More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport\",\"format\":\"int32\",\"type\":\"integer\"},\"port\":{\"default\":0,\"description\":\"The port that will be exposed by this service.\",\"format\":\"int32\",\"type\":\"integer\"},\"protocol\":{\"default\":\"TCP\",\"description\":\"The IP protocol for this port. Supports \\\"TCP\\\", \\\"UDP\\\", and \\\"SCTP\\\". Default is TCP.\",\"type\":\"string\"},\"targetPort\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.ServiceSpec\":{\"description\":\"ServiceSpec describes the attributes that a user creates on a service.\",\"properties\":{\"allocateLoadBalancerNodePorts\":{\"description\":\"allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is \\\"true\\\". It may be set to \\\"false\\\" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type.\",\"type\":\"boolean\"},\"clusterIP\":{\"description\":\"clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \\\"None\\\", empty string (\\\"\\\"), or a valid IP address. Setting this to \\\"None\\\" makes a \\\"headless service\\\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies\",\"type\":\"string\"},\"clusterIPs\":{\"description\":\"ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \\\"None\\\", empty string (\\\"\\\"), or a valid IP address. Setting this to \\\"None\\\" makes a \\\"headless service\\\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\\n\\nThis field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"externalIPs\":{\"description\":\"externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"externalName\":{\"description\":\"externalName is the external reference that discovery mechanisms will return as an alias for this service (e.g. a DNS CNAME record). No proxying will be involved. Must be a lowercase RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires `type` to be \\\"ExternalName\\\".\",\"type\":\"string\"},\"externalTrafficPolicy\":{\"description\":\"externalTrafficPolicy describes how nodes distribute service traffic they receive on one of the Service's \\\"externally-facing\\\" addresses (NodePorts, ExternalIPs, and LoadBalancer IPs). If set to \\\"Local\\\", the proxy will configure the service in a way that assumes that external load balancers will take care of balancing the service traffic between nodes, and so each node will deliver traffic only to the node-local endpoints of the service, without masquerading the client source IP. (Traffic mistakenly sent to a node with no endpoints will be dropped.) The default value, \\\"Cluster\\\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features). Note that traffic sent to an External IP or LoadBalancer IP from within the cluster will always get \\\"Cluster\\\" semantics, but clients sending to a NodePort from within the cluster may need to take traffic policy into account when picking a node.\",\"type\":\"string\"},\"healthCheckNodePort\":{\"description\":\"healthCheckNodePort specifies the healthcheck nodePort for the service. This only applies when type is set to LoadBalancer and externalTrafficPolicy is set to Local. If a value is specified, is in-range, and is not in use, it will be used. If not specified, a value will be automatically allocated. External systems (e.g. load-balancers) can use this port to determine if a given node holds endpoints for this service or not. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type). This field cannot be updated once set.\",\"format\":\"int32\",\"type\":\"integer\"},\"internalTrafficPolicy\":{\"description\":\"InternalTrafficPolicy describes how nodes distribute service traffic they receive on the ClusterIP. If set to \\\"Local\\\", the proxy will assume that pods only want to talk to endpoints of the service on the same node as the pod, dropping the traffic if there are no local endpoints. The default value, \\\"Cluster\\\", uses the standard behavior of routing to all endpoints evenly (possibly modified by topology and other features).\",\"type\":\"string\"},\"ipFamilies\":{\"description\":\"IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \\\"IPv4\\\" and \\\"IPv6\\\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \\\"headless\\\" services. This field will be wiped when updating a Service to type ExternalName.\\n\\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ipFamilyPolicy\":{\"description\":\"IPFamilyPolicy represents the dual-stack-ness requested or required by this Service. If there is no value provided, then this field will be set to SingleStack. Services can be \\\"SingleStack\\\" (a single IP family), \\\"PreferDualStack\\\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \\\"RequireDualStack\\\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.\",\"type\":\"string\"},\"loadBalancerClass\":{\"description\":\"loadBalancerClass is the class of the load balancer implementation this Service belongs to. If specified, the value of this field must be a label-style identifier, with an optional prefix, e.g. \\\"internal-vip\\\" or \\\"example.com/internal-vip\\\". Unprefixed names are reserved for end-users. This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load balancer implementation is used, today this is typically done through the cloud provider integration, but should apply for any default implementation. If set, it is assumed that a load balancer implementation is watching for Services with a matching class. Any default load balancer implementation (e.g. cloud providers) should ignore Services that set this field. This field can only be set when creating or updating a Service to type 'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.\",\"type\":\"string\"},\"loadBalancerIP\":{\"description\":\"Only applies to Service Type: LoadBalancer. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. Deprecated: This field was under-specified and its meaning varies across implementations. Using it is non-portable and it may not support dual-stack. Users are encouraged to use implementation-specific annotations when available.\",\"type\":\"string\"},\"loadBalancerSourceRanges\":{\"description\":\"If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\\\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"ports\":{\"description\":\"The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServicePort\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"port\",\"protocol\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"port\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"publishNotReadyAddresses\":{\"description\":\"publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service should disregard any indications of ready/not-ready. The primary use case for setting this field is for a StatefulSet's Headless Service to propagate SRV DNS records for its Pods for the purpose of peer discovery. The Kubernetes controllers that generate Endpoints and EndpointSlice resources for Services interpret this to mean that all endpoints are considered \\\"ready\\\" even if the Pods themselves are not. Agents which consume only Kubernetes generated endpoints through the Endpoints or EndpointSlice resources can safely assume this behavior.\",\"type\":\"boolean\"},\"selector\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/\",\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"sessionAffinity\":{\"description\":\"Supports \\\"ClientIP\\\" and \\\"None\\\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies\",\"type\":\"string\"},\"sessionAffinityConfig\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig\"},\"trafficDistribution\":{\"description\":\"TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to \\\"PreferClose\\\", implementations should prioritize endpoints that are in the same zone.\",\"type\":\"string\"},\"type\":{\"description\":\"type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \\\"ClusterIP\\\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is \\\"None\\\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. \\\"NodePort\\\" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. \\\"LoadBalancer\\\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. \\\"ExternalName\\\" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.ServiceStatus\":{\"description\":\"ServiceStatus represents the current status of a service.\",\"properties\":{\"conditions\":{\"description\":\"Current service state\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"type\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"type\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"loadBalancer\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SessionAffinityConfig\":{\"description\":\"SessionAffinityConfig represents the configurations of session affinity.\",\"properties\":{\"clientIP\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ClientIPConfig\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.SleepAction\":{\"description\":\"SleepAction describes a \\\"sleep\\\" action.\",\"properties\":{\"seconds\":{\"default\":0,\"description\":\"Seconds is the number of seconds to sleep.\",\"format\":\"int64\",\"type\":\"integer\"}},\"required\":[\"seconds\"],\"type\":\"object\"},\"io.k8s.api.core.v1.StorageOSPersistentVolumeSource\":{\"description\":\"Represents a StorageOS persistent volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ObjectReference\"},\"volumeName\":{\"description\":\"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.\",\"type\":\"string\"},\"volumeNamespace\":{\"description\":\"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \\\"default\\\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.StorageOSVolumeSource\":{\"description\":\"Represents a StorageOS persistent volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.\",\"type\":\"boolean\"},\"secretRef\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LocalObjectReference\"},\"volumeName\":{\"description\":\"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.\",\"type\":\"string\"},\"volumeNamespace\":{\"description\":\"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \\\"default\\\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.Sysctl\":{\"description\":\"Sysctl defines a kernel parameter to be set\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name of a property to set\",\"type\":\"string\"},\"value\":{\"default\":\"\",\"description\":\"Value of a property to set\",\"type\":\"string\"}},\"required\":[\"name\",\"value\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TCPSocketAction\":{\"description\":\"TCPSocketAction describes an action based on opening a socket\",\"properties\":{\"host\":{\"description\":\"Optional: Host name to connect to, defaults to the pod IP.\",\"type\":\"string\"},\"port\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString\"}},\"required\":[\"port\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Taint\":{\"description\":\"The node this Taint is attached to has the \\\"effect\\\" on any pod that does not tolerate the Taint.\",\"properties\":{\"effect\":{\"default\":\"\",\"description\":\"Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute.\",\"type\":\"string\"},\"key\":{\"default\":\"\",\"description\":\"Required. The taint key to be applied to a node.\",\"type\":\"string\"},\"timeAdded\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"value\":{\"description\":\"The taint value corresponding to the taint key.\",\"type\":\"string\"}},\"required\":[\"key\",\"effect\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Toleration\":{\"description\":\"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .\",\"properties\":{\"effect\":{\"description\":\"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\",\"type\":\"string\"},\"key\":{\"description\":\"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.\",\"type\":\"string\"},\"operator\":{\"description\":\"Operator represents a key's relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).\",\"type\":\"string\"},\"tolerationSeconds\":{\"description\":\"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.\",\"format\":\"int64\",\"type\":\"integer\"},\"value\":{\"description\":\"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.TopologySpreadConstraint\":{\"description\":\"TopologySpreadConstraint specifies how to spread matching pods among the given topology.\",\"properties\":{\"labelSelector\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\"},\"matchLabelKeys\":{\"description\":\"MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. MatchLabelKeys cannot be set when LabelSelector isn't set. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.\\n\\nThis is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"maxSkew\":{\"default\":0,\"description\":\"MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.\",\"format\":\"int32\",\"type\":\"integer\"},\"minDomains\":{\"description\":\"MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \\\"global minimum\\\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\\n\\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \\\"global minimum\\\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\",\"format\":\"int32\",\"type\":\"integer\"},\"nodeAffinityPolicy\":{\"description\":\"NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.\\n\\nIf this value is nil, the behavior is equivalent to the Honor policy.\",\"type\":\"string\"},\"nodeTaintsPolicy\":{\"description\":\"NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.\\n\\nIf this value is nil, the behavior is equivalent to the Ignore policy.\",\"type\":\"string\"},\"topologyKey\":{\"default\":\"\",\"description\":\"TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \\\"bucket\\\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \\\"kubernetes.io/hostname\\\", each Node is a domain of that topology. And, if TopologyKey is \\\"topology.kubernetes.io/zone\\\", each zone is a domain of that topology. It's a required field.\",\"type\":\"string\"},\"whenUnsatisfiable\":{\"default\":\"\",\"description\":\"WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\\n but giving higher precedence to topologies that would help reduce the\\n skew.\\nA constraint is considered \\\"Unsatisfiable\\\" for an incoming pod if and only if every possible node assignment for that pod would violate \\\"MaxSkew\\\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.\",\"type\":\"string\"}},\"required\":[\"maxSkew\",\"topologyKey\",\"whenUnsatisfiable\"],\"type\":\"object\"},\"io.k8s.api.core.v1.TypedLocalObjectReference\":{\"description\":\"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.api.core.v1.TypedObjectReference\":{\"description\":\"TypedObjectReference contains enough information to let you locate the typed referenced object\",\"properties\":{\"apiGroup\":{\"description\":\"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"Kind is the type of resource being referenced\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name is the name of resource being referenced\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.\",\"type\":\"string\"}},\"required\":[\"kind\",\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.Volume\":{\"description\":\"Volume represents a named volume in a pod that may be accessed by any container in the pod.\",\"properties\":{\"awsElasticBlockStore\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource\"},\"azureDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource\"},\"azureFile\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource\"},\"cephfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource\"},\"cinder\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CinderVolumeSource\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource\"},\"csi\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.CSIVolumeSource\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource\"},\"emptyDir\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource\"},\"ephemeral\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource\"},\"fc\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FCVolumeSource\"},\"flexVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FlexVolumeSource\"},\"flocker\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource\"},\"gcePersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource\"},\"gitRepo\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource\"},\"glusterfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource\"},\"hostPath\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource\"},\"image\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ImageVolumeSource\"},\"iscsi\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource\"},\"name\":{\"default\":\"\",\"description\":\"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names\",\"type\":\"string\"},\"nfs\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NFSVolumeSource\"},\"persistentVolumeClaim\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource\"},\"photonPersistentDisk\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource\"},\"portworxVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource\"},\"projected\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource\"},\"quobyte\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource\"},\"rbd\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.RBDVolumeSource\"},\"scaleIO\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretVolumeSource\"},\"storageos\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource\"},\"vsphereVolume\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\"}},\"required\":[\"name\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeDevice\":{\"description\":\"volumeDevice describes a mapping of a raw block device within a container.\",\"properties\":{\"devicePath\":{\"default\":\"\",\"description\":\"devicePath is the path inside of the container that the device will be mapped to.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name must match the name of a persistentVolumeClaim in the pod\",\"type\":\"string\"}},\"required\":[\"name\",\"devicePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeMount\":{\"description\":\"VolumeMount describes a mounting of a Volume within a container.\",\"properties\":{\"mountPath\":{\"default\":\"\",\"description\":\"Path within the container at which the volume should be mounted. Must not contain ':'.\",\"type\":\"string\"},\"mountPropagation\":{\"description\":\"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None).\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"This must match the Name of a Volume.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.\",\"type\":\"boolean\"},\"recursiveReadOnly\":{\"description\":\"RecursiveReadOnly specifies whether read-only mounts should be handled recursively.\\n\\nIf ReadOnly is false, this field has no meaning and must be unspecified.\\n\\nIf ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason.\\n\\nIf this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None).\\n\\nIf this field is not specified, it is treated as an equivalent of Disabled.\",\"type\":\"string\"},\"subPath\":{\"description\":\"Path within the volume from which the container's volume should be mounted. Defaults to \\\"\\\" (volume's root).\",\"type\":\"string\"},\"subPathExpr\":{\"description\":\"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references \$(VAR_NAME) are expanded using the container's environment. Defaults to \\\"\\\" (volume's root). SubPathExpr and SubPath are mutually exclusive.\",\"type\":\"string\"}},\"required\":[\"name\",\"mountPath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeMountStatus\":{\"description\":\"VolumeMountStatus shows status of volume mounts.\",\"properties\":{\"mountPath\":{\"default\":\"\",\"description\":\"MountPath corresponds to the original VolumeMount.\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name corresponds to the name of the original VolumeMount.\",\"type\":\"string\"},\"readOnly\":{\"description\":\"ReadOnly corresponds to the original VolumeMount.\",\"type\":\"boolean\"},\"recursiveReadOnly\":{\"description\":\"RecursiveReadOnly must be set to Disabled, Enabled, or unspecified (for non-readonly mounts). An IfPossible value in the original VolumeMount must be translated to Disabled or Enabled, depending on the mount result.\",\"type\":\"string\"}},\"required\":[\"name\",\"mountPath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeNodeAffinity\":{\"description\":\"VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.\",\"properties\":{\"required\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeSelector\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeProjection\":{\"description\":\"Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.\",\"properties\":{\"clusterTrustBundle\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection\"},\"configMap\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapProjection\"},\"downwardAPI\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection\"},\"podCertificate\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodCertificateProjection\"},\"secret\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretProjection\"},\"serviceAccountToken\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VolumeResourceRequirements\":{\"description\":\"VolumeResourceRequirements describes the storage resource requirements for a volume.\",\"properties\":{\"limits\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"description\":\"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"},\"requests\":{\"additionalProperties\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity\"},\"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. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\",\"type\":\"object\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource\":{\"description\":\"Represents a vSphere volume resource.\",\"properties\":{\"fsType\":{\"description\":\"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \\\"ext4\\\", \\\"xfs\\\", \\\"ntfs\\\". Implicitly inferred to be \\\"ext4\\\" if unspecified.\",\"type\":\"string\"},\"storagePolicyID\":{\"description\":\"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.\",\"type\":\"string\"},\"storagePolicyName\":{\"description\":\"storagePolicyName is the storage Policy Based Management (SPBM) profile name.\",\"type\":\"string\"},\"volumePath\":{\"default\":\"\",\"description\":\"volumePath is the path that identifies vSphere volume vmdk\",\"type\":\"string\"}},\"required\":[\"volumePath\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WeightedPodAffinityTerm\":{\"description\":\"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\",\"properties\":{\"podAffinityTerm\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodAffinityTerm\"},\"weight\":{\"default\":0,\"description\":\"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\",\"format\":\"int32\",\"type\":\"integer\"}},\"required\":[\"weight\",\"podAffinityTerm\"],\"type\":\"object\"},\"io.k8s.api.core.v1.WindowsSecurityContextOptions\":{\"description\":\"WindowsSecurityContextOptions contain Windows-specific options and credentials.\",\"properties\":{\"gmsaCredentialSpec\":{\"description\":\"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.\",\"type\":\"string\"},\"gmsaCredentialSpecName\":{\"description\":\"GMSACredentialSpecName is the name of the GMSA credential spec to use.\",\"type\":\"string\"},\"hostProcess\":{\"description\":\"HostProcess determines if a container should be run as a 'Host Process' container. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.\",\"type\":\"boolean\"},\"runAsUserName\":{\"description\":\"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.api.core.v1.WorkloadReference\":{\"description\":\"WorkloadReference identifies the Workload object and PodGroup membership that a Pod belongs to. The scheduler uses this information to apply workload-aware scheduling semantics.\",\"properties\":{\"name\":{\"default\":\"\",\"description\":\"Name defines the name of the Workload object this Pod belongs to. Workload must be in the same namespace as the Pod. If it doesn't match any existing Workload, the Pod will remain unschedulable until a Workload object is created and observed by the kube-scheduler. It must be a DNS subdomain.\",\"type\":\"string\"},\"podGroup\":{\"default\":\"\",\"description\":\"PodGroup is the name of the PodGroup within the Workload that this Pod belongs to. If it doesn't match any existing PodGroup within the Workload, the Pod will remain unschedulable until the Workload object is recreated and observed by the kube-scheduler. It must be a DNS label.\",\"type\":\"string\"},\"podGroupReplicaKey\":{\"description\":\"PodGroupReplicaKey specifies the replica key of the PodGroup to which this Pod belongs. It is used to distinguish pods belonging to different replicas of the same pod group. The pod group policy is applied separately to each replica. When set, it must be a DNS label.\",\"type\":\"string\"}},\"required\":[\"name\",\"podGroup\"],\"type\":\"object\"},\"io.k8s.api.policy.v1.Eviction\":{\"description\":\"Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"deleteOptions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"policy\",\"kind\":\"Eviction\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.api.resource.Quantity\":{\"description\":\"Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\\n\\nThe serialization format is:\\n\\n``` ::= \\n\\n\\t(Note that may be empty, from the \\\"\\\" case in .)\\n\\n ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= \\\"+\\\" | \\\"-\\\" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei\\n\\n\\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\\n\\n ::= m | \\\"\\\" | k | M | G | T | P | E\\n\\n\\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\\n\\n ::= \\\"e\\\" | \\\"E\\\" ```\\n\\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\\n\\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\\n\\nBefore serializing, Quantity will be put in \\\"canonical form\\\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\\n\\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\\n\\nThe sign will be omitted unless the number is negative.\\n\\nExamples:\\n\\n- 1.5 will be serialized as \\\"1500m\\\" - 1.5Gi will be serialized as \\\"1536Mi\\\"\\n\\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\\n\\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\\n\\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.\",\"oneOf\":[{\"type\":\"string\"},{\"type\":\"number\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\":{\"description\":\"APIResource specifies the name of a resource and whether it is namespaced.\",\"properties\":{\"categories\":{\"description\":\"categories is a list of the grouped resources this resource belongs to (e.g. 'all')\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\\\".\",\"type\":\"string\"},\"kind\":{\"default\":\"\",\"description\":\"kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"name is the plural name of the resource.\",\"type\":\"string\"},\"namespaced\":{\"default\":false,\"description\":\"namespaced indicates if a resource is namespaced or not.\",\"type\":\"boolean\"},\"shortNames\":{\"description\":\"shortNames is a list of suggested short names of the resource.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"singularName\":{\"default\":\"\",\"description\":\"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.\",\"type\":\"string\"},\"storageVersionHash\":{\"description\":\"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.\",\"type\":\"string\"},\"verbs\":{\"description\":\"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"nullable\":true},\"version\":{\"description\":\"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\\\".\",\"type\":\"string\"}},\"required\":[\"name\",\"singularName\",\"namespaced\",\"kind\",\"verbs\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\":{\"description\":\"APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"groupVersion\":{\"default\":\"\",\"description\":\"groupVersion is the group and version this APIResourceList is for.\",\"type\":\"string\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"resources\":{\"description\":\"resources contains the name of the resources and if they are namespaced.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"groupVersion\",\"resources\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"APIResourceList\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.Condition\":{\"description\":\"Condition contains details for one aspect of the current state of this API Resource.\",\"properties\":{\"lastTransitionTime\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"message\":{\"default\":\"\",\"description\":\"message is a human readable message indicating details about the transition. This may be an empty string.\",\"type\":\"string\"},\"observedGeneration\":{\"description\":\"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.\",\"format\":\"int64\",\"type\":\"integer\"},\"reason\":{\"default\":\"\",\"description\":\"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.\",\"type\":\"string\"},\"status\":{\"default\":\"\",\"description\":\"status of the condition, one of True, False, Unknown.\",\"type\":\"string\"},\"type\":{\"default\":\"\",\"description\":\"type of condition in CamelCase or in foo.example.com/CamelCase.\",\"type\":\"string\"}},\"required\":[\"type\",\"status\",\"lastTransitionTime\",\"reason\",\"message\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\":{\"description\":\"DeleteOptions may be provided when deleting an API object.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"dryRun\":{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"gracePeriodSeconds\":{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"format\":\"int64\",\"type\":\"integer\"},\"ignoreStoreReadErrorWithClusterBreakingPotential\":{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"type\":\"boolean\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"orphanDependents\":{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"type\":\"boolean\"},\"preconditions\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\"},\"propagationPolicy\":{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"DeleteOptions\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"DeleteOptions\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\":{\"description\":\"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\\n\\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\\n\\nThe exact format is defined in sigs.k8s.io/structured-merge-diff\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector\":{\"description\":\"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.\",\"properties\":{\"matchExpressions\":{\"description\":\"matchExpressions is a list of label selector requirements. The requirements are ANDed.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"matchLabels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \\\"key\\\", the operator is \\\"In\\\", and the values array contains only \\\"value\\\". The requirements are ANDed.\",\"type\":\"object\"}},\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement\":{\"description\":\"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\",\"properties\":{\"key\":{\"default\":\"\",\"description\":\"key is the label key that the selector applies to.\",\"type\":\"string\"},\"operator\":{\"default\":\"\",\"description\":\"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\",\"type\":\"string\"},\"values\":{\"description\":\"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true}},\"required\":[\"key\",\"operator\"],\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\":{\"description\":\"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.\",\"properties\":{\"continue\":{\"description\":\"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message.\",\"type\":\"string\"},\"remainingItemCount\":{\"description\":\"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact.\",\"format\":\"int64\",\"type\":\"integer\"},\"resourceVersion\":{\"description\":\"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\":{\"description\":\"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the version of this resource that this field set applies to. The format is \\\"group/version\\\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.\",\"type\":\"string\"},\"fieldsType\":{\"description\":\"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \\\"FieldsV1\\\"\",\"type\":\"string\"},\"fieldsV1\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1\"},\"manager\":{\"description\":\"Manager is an identifier of the workflow managing these fields.\",\"type\":\"string\"},\"operation\":{\"description\":\"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.\",\"type\":\"string\"},\"subresource\":{\"description\":\"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.\",\"type\":\"string\"},\"time\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime\":{\"description\":\"MicroTime is version of Time with microsecond level precision.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta\":{\"description\":\"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.\",\"properties\":{\"annotations\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations\",\"type\":\"object\"},\"creationTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"deletionGracePeriodSeconds\":{\"description\":\"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"deletionTimestamp\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time\"},\"finalizers\":{\"description\":\"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.\",\"items\":{\"default\":\"\",\"type\":\"string\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"set\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"generateName\":{\"description\":\"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\\n\\nIf this field is specified and the generated name exists, the server will return a 409.\\n\\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency\",\"type\":\"string\"},\"generation\":{\"description\":\"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.\",\"format\":\"int64\",\"type\":\"integer\"},\"labels\":{\"additionalProperties\":{\"default\":\"\",\"type\":\"string\"},\"description\":\"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels\",\"type\":\"object\"},\"managedFields\":{\"description\":\"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \\\"ci-cd\\\". The set of fields is always in the version that the workflow used when modifying the object.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"name\":{\"description\":\"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"namespace\":{\"description\":\"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \\\"default\\\" namespace, but \\\"default\\\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\\n\\nMust be a DNS_LABEL. Cannot be updated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces\",\"type\":\"string\"},\"ownerReferences\":{\"description\":\"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-map-keys\":[\"uid\"],\"x-kubernetes-list-type\":\"map\",\"x-kubernetes-patch-merge-key\":\"uid\",\"x-kubernetes-patch-strategy\":\"merge\",\"nullable\":true},\"resourceVersion\":{\"description\":\"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\\n\\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency\",\"type\":\"string\"},\"selfLink\":{\"description\":\"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.\",\"type\":\"string\"},\"uid\":{\"description\":\"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\\n\\nPopulated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference\":{\"description\":\"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.\",\"properties\":{\"apiVersion\":{\"default\":\"\",\"description\":\"API version of the referent.\",\"type\":\"string\"},\"blockOwnerDeletion\":{\"description\":\"If true, AND if the owner has the \\\"foregroundDeletion\\\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \\\"delete\\\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.\",\"type\":\"boolean\"},\"controller\":{\"description\":\"If true, this reference points to the managing controller.\",\"type\":\"boolean\"},\"kind\":{\"default\":\"\",\"description\":\"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"default\":\"\",\"description\":\"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names\",\"type\":\"string\"},\"uid\":{\"default\":\"\",\"description\":\"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"required\":[\"apiVersion\",\"kind\",\"name\",\"uid\"],\"type\":\"object\",\"x-kubernetes-map-type\":\"atomic\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Patch\":{\"description\":\"Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions\":{\"description\":\"Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.\",\"properties\":{\"resourceVersion\":{\"description\":\"Specifies the target ResourceVersion\",\"type\":\"string\"},\"uid\":{\"description\":\"Specifies the target UID.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Status\":{\"description\":\"Status is a return value for calls that don't return other objects.\",\"properties\":{\"apiVersion\":{\"description\":\"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources\",\"type\":\"string\"},\"code\":{\"description\":\"Suggested HTTP return code for this status, 0 if not set.\",\"format\":\"int32\",\"type\":\"integer\"},\"details\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\"},\"kind\":{\"description\":\"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the status of this operation.\",\"type\":\"string\"},\"metadata\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta\"},\"reason\":{\"description\":\"A machine-readable description of why this operation is in the \\\"Failure\\\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it.\",\"type\":\"string\"},\"status\":{\"description\":\"Status of the operation. One of: \\\"Success\\\" or \\\"Failure\\\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status\",\"type\":\"string\"}},\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"Status\",\"version\":\"v1\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\":{\"description\":\"StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.\",\"properties\":{\"field\":{\"description\":\"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.\\n\\nExamples:\\n \\\"name\\\" - the field \\\"name\\\" on the current resource\\n \\\"items[0].name\\\" - the field \\\"name\\\" on the first array entry in \\\"items\\\"\",\"type\":\"string\"},\"message\":{\"description\":\"A human-readable description of the cause of the error. This field may be presented as-is to a reader.\",\"type\":\"string\"},\"reason\":{\"description\":\"A machine-readable description of the cause of the error. If this value is empty there is no information available.\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails\":{\"description\":\"StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined.\",\"properties\":{\"causes\":{\"description\":\"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.\",\"items\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause\"},\"type\":[\"array\",\"null\"],\"x-kubernetes-list-type\":\"atomic\",\"nullable\":true},\"group\":{\"description\":\"The group attribute of the resource associated with the status StatusReason.\",\"type\":\"string\"},\"kind\":{\"description\":\"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\",\"type\":\"string\"},\"name\":{\"description\":\"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).\",\"type\":\"string\"},\"retryAfterSeconds\":{\"description\":\"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.\",\"format\":\"int32\",\"type\":\"integer\"},\"uid\":{\"description\":\"UID of the resource. (when there is a single resource which can be described). More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids\",\"type\":\"string\"}},\"type\":\"object\"},\"io.k8s.apimachinery.pkg.apis.meta.v1.Time\":{\"description\":\"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers.\",\"format\":\"date-time\",\"type\":[\"string\",\"null\"],\"nullable\":true},\"io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\":{\"description\":\"Event represents a single event to a watched resource.\",\"properties\":{\"object\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension\"},\"type\":{\"default\":\"\",\"type\":\"string\"}},\"required\":[\"type\",\"object\"],\"type\":\"object\",\"x-kubernetes-group-version-kind\":[{\"group\":\"\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admission.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"admissionregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiextensions.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apiregistration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"apps\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"authentication.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta1\"},{\"group\":\"autoscaling\",\"kind\":\"WatchEvent\",\"version\":\"v2beta2\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"batch\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"certificates.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha2\"},{\"group\":\"coordination.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"discovery.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"events.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"extensions\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"flowcontrol.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta3\"},{\"group\":\"imagepolicy.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"internal.apiserver.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"networking.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"node.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"policy\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"rbac.authorization.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha3\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"resource.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta2\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"scheduling.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1alpha1\"},{\"group\":\"storage.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"},{\"group\":\"storagemigration.k8s.io\",\"kind\":\"WatchEvent\",\"version\":\"v1beta1\"}]},\"io.k8s.apimachinery.pkg.runtime.RawExtension\":{\"description\":\"RawExtension is used to hold extensions in external versions.\\n\\nTo use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.\\n\\n// Internal package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.Object `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// External package:\\n\\n\\ttype MyAPIObject struct {\\n\\t\\truntime.TypeMeta `json:\\\",inline\\\"`\\n\\t\\tMyPlugin runtime.RawExtension `json:\\\"myPlugin\\\"`\\n\\t}\\n\\n\\ttype PluginA struct {\\n\\t\\tAOption string `json:\\\"aOption\\\"`\\n\\t}\\n\\n// On the wire, the JSON will look something like this:\\n\\n\\t{\\n\\t\\t\\\"kind\\\":\\\"MyAPIObject\\\",\\n\\t\\t\\\"apiVersion\\\":\\\"v1\\\",\\n\\t\\t\\\"myPlugin\\\": {\\n\\t\\t\\t\\\"kind\\\":\\\"PluginA\\\",\\n\\t\\t\\t\\\"aOption\\\":\\\"foo\\\",\\n\\t\\t},\\n\\t}\\n\\nSo what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)\",\"type\":\"object\"},\"io.k8s.apimachinery.pkg.util.intstr.IntOrString\":{\"description\":\"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.\",\"format\":\"int-or-string\",\"oneOf\":[{\"type\":\"integer\"},{\"type\":\"string\"}]},\"io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\":{\"description\":\"A JSON Patch document (RFC 6902): the sequence of operations to apply to the target object.\",\"type\":\"array\",\"items\":{\"type\":\"object\"}}},\"securitySchemes\":{\"BearerToken\":{\"description\":\"Bearer Token authentication\",\"in\":\"header\",\"name\":\"authorization\",\"type\":\"apiKey\"}}},\"info\":{\"title\":\"Kubernetes\",\"version\":\"unversioned\"},\"openapi\":\"3.0.0\",\"paths\":{\"/api/v1/\":{\"get\":{\"description\":\"get available resources\",\"operationId\":\"getCoreV1APIResources\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"]}},\"/api/v1/componentstatuses\":{\"get\":{\"description\":\"list objects of kind ComponentStatus\",\"operationId\":\"listCoreV1ComponentStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatusList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ComponentStatus\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/componentstatuses/{name}\":{\"get\":{\"description\":\"read the specified ComponentStatus\",\"operationId\":\"readCoreV1ComponentStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatus\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatus\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatus\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ComponentStatus\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ComponentStatus\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ComponentStatus\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"/api/v1/configmaps\":{\"get\":{\"description\":\"list or watch objects of kind ConfigMap\",\"operationId\":\"listCoreV1ConfigMapForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/endpoints\":{\"get\":{\"description\":\"list or watch objects of kind Endpoints\",\"operationId\":\"listCoreV1EndpointsForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/events\":{\"get\":{\"description\":\"list or watch objects of kind Event\",\"operationId\":\"listCoreV1EventForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/limitranges\":{\"get\":{\"description\":\"list or watch objects of kind LimitRange\",\"operationId\":\"listCoreV1LimitRangeForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/namespaces\":{\"get\":{\"description\":\"list or watch objects of kind Namespace\",\"operationId\":\"listCoreV1Namespace\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NamespaceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Namespace\",\"operationId\":\"createCoreV1Namespace\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/bindings\":{\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Binding\",\"operationId\":\"createCoreV1NamespacedBinding\",\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Binding\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/configmaps\":{\"delete\":{\"description\":\"delete collection of ConfigMap\",\"operationId\":\"deleteCoreV1CollectionNamespacedConfigMap\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ConfigMap\",\"operationId\":\"listCoreV1NamespacedConfigMap\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMapList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ConfigMap\",\"operationId\":\"createCoreV1NamespacedConfigMap\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/configmaps/{name}\":{\"delete\":{\"description\":\"delete a ConfigMap\",\"operationId\":\"deleteCoreV1NamespacedConfigMap\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ConfigMap\",\"operationId\":\"readCoreV1NamespacedConfigMap\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ConfigMap\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ConfigMap\",\"operationId\":\"patchCoreV1NamespacedConfigMap\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ConfigMap\",\"operationId\":\"replaceCoreV1NamespacedConfigMap\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ConfigMap\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/endpoints\":{\"delete\":{\"description\":\"delete collection of Endpoints\",\"operationId\":\"deleteCoreV1CollectionNamespacedEndpoints\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Endpoints\",\"operationId\":\"listCoreV1NamespacedEndpoints\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EndpointsList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create Endpoints\",\"operationId\":\"createCoreV1NamespacedEndpoints\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/endpoints/{name}\":{\"delete\":{\"description\":\"delete Endpoints\",\"operationId\":\"deleteCoreV1NamespacedEndpoints\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Endpoints\",\"operationId\":\"readCoreV1NamespacedEndpoints\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Endpoints\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Endpoints\",\"operationId\":\"patchCoreV1NamespacedEndpoints\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Endpoints\",\"operationId\":\"replaceCoreV1NamespacedEndpoints\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Endpoints\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/events\":{\"delete\":{\"description\":\"delete collection of Event\",\"operationId\":\"deleteCoreV1CollectionNamespacedEvent\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Event\",\"operationId\":\"listCoreV1NamespacedEvent\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.EventList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create an Event\",\"operationId\":\"createCoreV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/events/{name}\":{\"delete\":{\"description\":\"delete an Event\",\"operationId\":\"deleteCoreV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Event\",\"operationId\":\"readCoreV1NamespacedEvent\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Event\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Event\",\"operationId\":\"patchCoreV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Event\",\"operationId\":\"replaceCoreV1NamespacedEvent\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Event\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/limitranges\":{\"delete\":{\"description\":\"delete collection of LimitRange\",\"operationId\":\"deleteCoreV1CollectionNamespacedLimitRange\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind LimitRange\",\"operationId\":\"listCoreV1NamespacedLimitRange\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRangeList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a LimitRange\",\"operationId\":\"createCoreV1NamespacedLimitRange\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/limitranges/{name}\":{\"delete\":{\"description\":\"delete a LimitRange\",\"operationId\":\"deleteCoreV1NamespacedLimitRange\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified LimitRange\",\"operationId\":\"readCoreV1NamespacedLimitRange\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the LimitRange\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified LimitRange\",\"operationId\":\"patchCoreV1NamespacedLimitRange\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified LimitRange\",\"operationId\":\"replaceCoreV1NamespacedLimitRange\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.LimitRange\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/persistentvolumeclaims\":{\"delete\":{\"description\":\"delete collection of PersistentVolumeClaim\",\"operationId\":\"deleteCoreV1CollectionNamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind PersistentVolumeClaim\",\"operationId\":\"listCoreV1NamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a PersistentVolumeClaim\",\"operationId\":\"createCoreV1NamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}\":{\"delete\":{\"description\":\"delete a PersistentVolumeClaim\",\"operationId\":\"deleteCoreV1NamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified PersistentVolumeClaim\",\"operationId\":\"readCoreV1NamespacedPersistentVolumeClaim\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the PersistentVolumeClaim\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified PersistentVolumeClaim\",\"operationId\":\"patchCoreV1NamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified PersistentVolumeClaim\",\"operationId\":\"replaceCoreV1NamespacedPersistentVolumeClaim\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status\":{\"get\":{\"description\":\"read status of the specified PersistentVolumeClaim\",\"operationId\":\"readCoreV1NamespacedPersistentVolumeClaimStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PersistentVolumeClaim\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified PersistentVolumeClaim\",\"operationId\":\"patchCoreV1NamespacedPersistentVolumeClaimStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified PersistentVolumeClaim\",\"operationId\":\"replaceCoreV1NamespacedPersistentVolumeClaimStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods\":{\"delete\":{\"description\":\"delete collection of Pod\",\"operationId\":\"deleteCoreV1CollectionNamespacedPod\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Pod\",\"operationId\":\"listCoreV1NamespacedPod\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Pod\",\"operationId\":\"createCoreV1NamespacedPod\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}\":{\"delete\":{\"description\":\"delete a Pod\",\"operationId\":\"deleteCoreV1NamespacedPod\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Pod\",\"operationId\":\"readCoreV1NamespacedPod\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Pod\",\"operationId\":\"patchCoreV1NamespacedPod\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Pod\",\"operationId\":\"replaceCoreV1NamespacedPod\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/attach\":{\"get\":{\"description\":\"connect GET requests to attach of Pod\",\"operationId\":\"connectCoreV1GetNamespacedPodAttach\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodAttachOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"The container in which to execute the command. Defaults to only container if there is only one container in the pod.\",\"in\":\"query\",\"name\":\"container\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the PodAttachOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true.\",\"in\":\"query\",\"name\":\"stderr\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false.\",\"in\":\"query\",\"name\":\"stdin\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true.\",\"in\":\"query\",\"name\":\"stdout\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"TTY if true indicates that a tty will be allocated for the attach call. This is passed through the container runtime so the tty is allocated on the worker node by the container runtime. Defaults to false.\",\"in\":\"query\",\"name\":\"tty\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"post\":{\"description\":\"connect POST requests to attach of Pod\",\"operationId\":\"connectCoreV1PostNamespacedPodAttach\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodAttachOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/binding\":{\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the Binding\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create binding of a Pod\",\"operationId\":\"createCoreV1NamespacedPodBinding\",\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Binding\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Binding\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers\":{\"get\":{\"description\":\"read ephemeralcontainers of the specified Pod\",\"operationId\":\"readCoreV1NamespacedPodEphemeralcontainers\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update ephemeralcontainers of the specified Pod\",\"operationId\":\"patchCoreV1NamespacedPodEphemeralcontainers\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace ephemeralcontainers of the specified Pod\",\"operationId\":\"replaceCoreV1NamespacedPodEphemeralcontainers\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/eviction\":{\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the Eviction\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create eviction of a Pod\",\"operationId\":\"createCoreV1NamespacedPodEviction\",\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.policy.v1.Eviction\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"policy\",\"kind\":\"Eviction\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/exec\":{\"get\":{\"description\":\"connect GET requests to exec of Pod\",\"operationId\":\"connectCoreV1GetNamespacedPodExec\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodExecOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"Command is the remote command to execute. argv array. Not executed within a shell.\",\"in\":\"query\",\"name\":\"command\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Container in which to execute the command. Defaults to only container if there is only one container in the pod.\",\"in\":\"query\",\"name\":\"container\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the PodExecOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Redirect the standard error stream of the pod for this call.\",\"in\":\"query\",\"name\":\"stderr\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Redirect the standard input stream of the pod for this call. Defaults to false.\",\"in\":\"query\",\"name\":\"stdin\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Redirect the standard output stream of the pod for this call.\",\"in\":\"query\",\"name\":\"stdout\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"TTY if true indicates that a tty will be allocated for the exec call. Defaults to false.\",\"in\":\"query\",\"name\":\"tty\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"post\":{\"description\":\"connect POST requests to exec of Pod\",\"operationId\":\"connectCoreV1PostNamespacedPodExec\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodExecOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/log\":{\"get\":{\"description\":\"read log of the specified Pod\",\"operationId\":\"readCoreV1NamespacedPodLog\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"type\":\"string\"}},\"application/json\":{\"schema\":{\"type\":\"string\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"type\":\"string\"}},\"application/yaml\":{\"schema\":{\"type\":\"string\"}},\"text/plain\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"The container for which to stream logs. Defaults to only container if there is one container in the pod.\",\"in\":\"query\",\"name\":\"container\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Follow the log stream of the pod. Defaults to false.\",\"in\":\"query\",\"name\":\"follow\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"insecureSkipTLSVerifyBackend indicates that the apiserver should not confirm the validity of the serving certificate of the backend it is connecting to. This will make the HTTPS connection between the apiserver and the backend insecure. This means the apiserver cannot verify the log data it is receiving came from the real kubelet. If the kubelet is configured to verify the apiserver's TLS credentials, it does not mean the connection to the real kubelet is vulnerable to a man in the middle attack (e.g. an attacker could not intercept the actual log data coming from the real kubelet).\",\"in\":\"query\",\"name\":\"insecureSkipTLSVerifyBackend\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"If set, the number of bytes to read from the server before terminating the log output. This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit.\",\"in\":\"query\",\"name\":\"limitBytes\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Return previous terminated container logs. Defaults to false.\",\"in\":\"query\",\"name\":\"previous\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A relative time in seconds before the current time from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified.\",\"in\":\"query\",\"name\":\"sinceSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Specify which container log stream to return to the client. Acceptable values are \\\"All\\\", \\\"Stdout\\\" and \\\"Stderr\\\". If not specified, \\\"All\\\" is used, and both stdout and stderr are returned interleaved. Note that when \\\"TailLines\\\" is specified, \\\"Stream\\\" can only be set to nil or \\\"All\\\".\",\"in\":\"query\",\"name\":\"stream\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation of the container or sinceSeconds or sinceTime. Note that when \\\"TailLines\\\" is specified, \\\"Stream\\\" can only be set to nil or \\\"All\\\".\",\"in\":\"query\",\"name\":\"tailLines\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false.\",\"in\":\"query\",\"name\":\"timestamps\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/namespaces/{namespace}/pods/{name}/portforward\":{\"get\":{\"description\":\"connect GET requests to portforward of Pod\",\"operationId\":\"connectCoreV1GetNamespacedPodPortforward\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodPortForwardOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PodPortForwardOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"List of ports to forward Required when using WebSockets\",\"in\":\"query\",\"name\":\"ports\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"post\":{\"description\":\"connect POST requests to portforward of Pod\",\"operationId\":\"connectCoreV1PostNamespacedPodPortforward\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodPortForwardOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/proxy\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Pod\",\"operationId\":\"connectCoreV1DeleteNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Pod\",\"operationId\":\"connectCoreV1GetNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Pod\",\"operationId\":\"connectCoreV1HeadNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Pod\",\"operationId\":\"connectCoreV1OptionsNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PodProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the URL path to use for the current proxy request to pod.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Pod\",\"operationId\":\"connectCoreV1PatchNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Pod\",\"operationId\":\"connectCoreV1PostNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Pod\",\"operationId\":\"connectCoreV1PutNamespacedPodProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Pod\",\"operationId\":\"connectCoreV1DeleteNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Pod\",\"operationId\":\"connectCoreV1GetNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Pod\",\"operationId\":\"connectCoreV1HeadNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Pod\",\"operationId\":\"connectCoreV1OptionsNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PodProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"path to the resource\",\"in\":\"path\",\"name\":\"path\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the URL path to use for the current proxy request to pod.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Pod\",\"operationId\":\"connectCoreV1PatchNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Pod\",\"operationId\":\"connectCoreV1PostNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Pod\",\"operationId\":\"connectCoreV1PutNamespacedPodProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/resize\":{\"get\":{\"description\":\"read resize of the specified Pod\",\"operationId\":\"readCoreV1NamespacedPodResize\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update resize of the specified Pod\",\"operationId\":\"patchCoreV1NamespacedPodResize\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace resize of the specified Pod\",\"operationId\":\"replaceCoreV1NamespacedPodResize\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/pods/{name}/status\":{\"get\":{\"description\":\"read status of the specified Pod\",\"operationId\":\"readCoreV1NamespacedPodStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Pod\",\"operationId\":\"patchCoreV1NamespacedPodStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Pod\",\"operationId\":\"replaceCoreV1NamespacedPodStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Pod\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/podtemplates\":{\"delete\":{\"description\":\"delete collection of PodTemplate\",\"operationId\":\"deleteCoreV1CollectionNamespacedPodTemplate\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind PodTemplate\",\"operationId\":\"listCoreV1NamespacedPodTemplate\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a PodTemplate\",\"operationId\":\"createCoreV1NamespacedPodTemplate\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/podtemplates/{name}\":{\"delete\":{\"description\":\"delete a PodTemplate\",\"operationId\":\"deleteCoreV1NamespacedPodTemplate\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified PodTemplate\",\"operationId\":\"readCoreV1NamespacedPodTemplate\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the PodTemplate\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified PodTemplate\",\"operationId\":\"patchCoreV1NamespacedPodTemplate\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified PodTemplate\",\"operationId\":\"replaceCoreV1NamespacedPodTemplate\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplate\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/replicationcontrollers\":{\"delete\":{\"description\":\"delete collection of ReplicationController\",\"operationId\":\"deleteCoreV1CollectionNamespacedReplicationController\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ReplicationController\",\"operationId\":\"listCoreV1NamespacedReplicationController\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ReplicationController\",\"operationId\":\"createCoreV1NamespacedReplicationController\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/replicationcontrollers/{name}\":{\"delete\":{\"description\":\"delete a ReplicationController\",\"operationId\":\"deleteCoreV1NamespacedReplicationController\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ReplicationController\",\"operationId\":\"readCoreV1NamespacedReplicationController\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ReplicationController\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ReplicationController\",\"operationId\":\"patchCoreV1NamespacedReplicationController\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ReplicationController\",\"operationId\":\"replaceCoreV1NamespacedReplicationController\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale\":{\"get\":{\"description\":\"read scale of the specified ReplicationController\",\"operationId\":\"readCoreV1NamespacedReplicationControllerScale\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Scale\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update scale of the specified ReplicationController\",\"operationId\":\"patchCoreV1NamespacedReplicationControllerScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace scale of the specified ReplicationController\",\"operationId\":\"replaceCoreV1NamespacedReplicationControllerScale\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.autoscaling.v1.Scale\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"autoscaling\",\"kind\":\"Scale\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status\":{\"get\":{\"description\":\"read status of the specified ReplicationController\",\"operationId\":\"readCoreV1NamespacedReplicationControllerStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ReplicationController\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified ReplicationController\",\"operationId\":\"patchCoreV1NamespacedReplicationControllerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified ReplicationController\",\"operationId\":\"replaceCoreV1NamespacedReplicationControllerStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationController\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/resourcequotas\":{\"delete\":{\"description\":\"delete collection of ResourceQuota\",\"operationId\":\"deleteCoreV1CollectionNamespacedResourceQuota\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ResourceQuota\",\"operationId\":\"listCoreV1NamespacedResourceQuota\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ResourceQuota\",\"operationId\":\"createCoreV1NamespacedResourceQuota\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/resourcequotas/{name}\":{\"delete\":{\"description\":\"delete a ResourceQuota\",\"operationId\":\"deleteCoreV1NamespacedResourceQuota\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ResourceQuota\",\"operationId\":\"readCoreV1NamespacedResourceQuota\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ResourceQuota\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ResourceQuota\",\"operationId\":\"patchCoreV1NamespacedResourceQuota\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ResourceQuota\",\"operationId\":\"replaceCoreV1NamespacedResourceQuota\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/resourcequotas/{name}/status\":{\"get\":{\"description\":\"read status of the specified ResourceQuota\",\"operationId\":\"readCoreV1NamespacedResourceQuotaStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ResourceQuota\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified ResourceQuota\",\"operationId\":\"patchCoreV1NamespacedResourceQuotaStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified ResourceQuota\",\"operationId\":\"replaceCoreV1NamespacedResourceQuotaStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuota\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/secrets\":{\"delete\":{\"description\":\"delete collection of Secret\",\"operationId\":\"deleteCoreV1CollectionNamespacedSecret\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Secret\",\"operationId\":\"listCoreV1NamespacedSecret\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Secret\",\"operationId\":\"createCoreV1NamespacedSecret\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/secrets/{name}\":{\"delete\":{\"description\":\"delete a Secret\",\"operationId\":\"deleteCoreV1NamespacedSecret\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Secret\",\"operationId\":\"readCoreV1NamespacedSecret\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Secret\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Secret\",\"operationId\":\"patchCoreV1NamespacedSecret\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Secret\",\"operationId\":\"replaceCoreV1NamespacedSecret\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Secret\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/serviceaccounts\":{\"delete\":{\"description\":\"delete collection of ServiceAccount\",\"operationId\":\"deleteCoreV1CollectionNamespacedServiceAccount\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind ServiceAccount\",\"operationId\":\"listCoreV1NamespacedServiceAccount\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a ServiceAccount\",\"operationId\":\"createCoreV1NamespacedServiceAccount\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/serviceaccounts/{name}\":{\"delete\":{\"description\":\"delete a ServiceAccount\",\"operationId\":\"deleteCoreV1NamespacedServiceAccount\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified ServiceAccount\",\"operationId\":\"readCoreV1NamespacedServiceAccount\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the ServiceAccount\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified ServiceAccount\",\"operationId\":\"patchCoreV1NamespacedServiceAccount\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified ServiceAccount\",\"operationId\":\"replaceCoreV1NamespacedServiceAccount\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccount\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token\":{\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the TokenRequest\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create token of a ServiceAccount\",\"operationId\":\"createCoreV1NamespacedServiceAccountToken\",\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.authentication.v1.TokenRequest\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"authentication.k8s.io\",\"kind\":\"TokenRequest\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/services\":{\"delete\":{\"description\":\"delete collection of Service\",\"operationId\":\"deleteCoreV1CollectionNamespacedService\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Service\",\"operationId\":\"listCoreV1NamespacedService\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Service\",\"operationId\":\"createCoreV1NamespacedService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/services/{name}\":{\"delete\":{\"description\":\"delete a Service\",\"operationId\":\"deleteCoreV1NamespacedService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Service\",\"operationId\":\"readCoreV1NamespacedService\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Service\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Service\",\"operationId\":\"patchCoreV1NamespacedService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Service\",\"operationId\":\"replaceCoreV1NamespacedService\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/services/{name}/proxy\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Service\",\"operationId\":\"connectCoreV1DeleteNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Service\",\"operationId\":\"connectCoreV1GetNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Service\",\"operationId\":\"connectCoreV1HeadNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Service\",\"operationId\":\"connectCoreV1OptionsNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ServiceProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Service\",\"operationId\":\"connectCoreV1PatchNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Service\",\"operationId\":\"connectCoreV1PostNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Service\",\"operationId\":\"connectCoreV1PutNamespacedServiceProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Service\",\"operationId\":\"connectCoreV1DeleteNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Service\",\"operationId\":\"connectCoreV1GetNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Service\",\"operationId\":\"connectCoreV1HeadNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Service\",\"operationId\":\"connectCoreV1OptionsNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the ServiceProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"path to the resource\",\"in\":\"path\",\"name\":\"path\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Service\",\"operationId\":\"connectCoreV1PatchNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Service\",\"operationId\":\"connectCoreV1PostNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Service\",\"operationId\":\"connectCoreV1PutNamespacedServiceProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{namespace}/services/{name}/status\":{\"get\":{\"description\":\"read status of the specified Service\",\"operationId\":\"readCoreV1NamespacedServiceStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Service\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Service\",\"operationId\":\"patchCoreV1NamespacedServiceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Service\",\"operationId\":\"replaceCoreV1NamespacedServiceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Service\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{name}\":{\"delete\":{\"description\":\"delete a Namespace\",\"operationId\":\"deleteCoreV1Namespace\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Namespace\",\"operationId\":\"readCoreV1Namespace\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Namespace\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Namespace\",\"operationId\":\"patchCoreV1Namespace\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Namespace\",\"operationId\":\"replaceCoreV1Namespace\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{name}/finalize\":{\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"name of the Namespace\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"put\":{\"description\":\"replace finalize of the specified Namespace\",\"operationId\":\"replaceCoreV1NamespaceFinalize\",\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}}},\"/api/v1/namespaces/{name}/status\":{\"get\":{\"description\":\"read status of the specified Namespace\",\"operationId\":\"readCoreV1NamespaceStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Namespace\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Namespace\",\"operationId\":\"patchCoreV1NamespaceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Namespace\",\"operationId\":\"replaceCoreV1NamespaceStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Namespace\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}}},\"/api/v1/nodes\":{\"delete\":{\"description\":\"delete collection of Node\",\"operationId\":\"deleteCoreV1CollectionNode\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind Node\",\"operationId\":\"listCoreV1Node\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.NodeList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a Node\",\"operationId\":\"createCoreV1Node\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}}},\"/api/v1/nodes/{name}\":{\"delete\":{\"description\":\"delete a Node\",\"operationId\":\"deleteCoreV1Node\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified Node\",\"operationId\":\"readCoreV1Node\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the Node\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified Node\",\"operationId\":\"patchCoreV1Node\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified Node\",\"operationId\":\"replaceCoreV1Node\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}}},\"/api/v1/nodes/{name}/proxy\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Node\",\"operationId\":\"connectCoreV1DeleteNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Node\",\"operationId\":\"connectCoreV1GetNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Node\",\"operationId\":\"connectCoreV1HeadNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Node\",\"operationId\":\"connectCoreV1OptionsNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the NodeProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the URL path to use for the current proxy request to node.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Node\",\"operationId\":\"connectCoreV1PatchNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Node\",\"operationId\":\"connectCoreV1PostNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Node\",\"operationId\":\"connectCoreV1PutNodeProxy\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/nodes/{name}/proxy/{path}\":{\"delete\":{\"description\":\"connect DELETE requests to proxy of Node\",\"operationId\":\"connectCoreV1DeleteNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"get\":{\"description\":\"connect GET requests to proxy of Node\",\"operationId\":\"connectCoreV1GetNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"head\":{\"description\":\"connect HEAD requests to proxy of Node\",\"operationId\":\"connectCoreV1HeadNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"options\":{\"description\":\"connect OPTIONS requests to proxy of Node\",\"operationId\":\"connectCoreV1OptionsNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the NodeProxyOptions\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"path to the resource\",\"in\":\"path\",\"name\":\"path\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Path is the URL path to use for the current proxy request to node.\",\"in\":\"query\",\"name\":\"path\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"connect PATCH requests to proxy of Node\",\"operationId\":\"connectCoreV1PatchNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"post\":{\"description\":\"connect POST requests to proxy of Node\",\"operationId\":\"connectCoreV1PostNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}},\"put\":{\"description\":\"connect PUT requests to proxy of Node\",\"operationId\":\"connectCoreV1PutNodeProxyWithPath\",\"responses\":{\"200\":{\"content\":{\"*/*\":{\"schema\":{\"type\":\"string\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"connect\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"NodeProxyOptions\",\"version\":\"v1\"}}},\"/api/v1/nodes/{name}/status\":{\"get\":{\"description\":\"read status of the specified Node\",\"operationId\":\"readCoreV1NodeStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the Node\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified Node\",\"operationId\":\"patchCoreV1NodeStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified Node\",\"operationId\":\"replaceCoreV1NodeStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.Node\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}}},\"/api/v1/persistentvolumeclaims\":{\"get\":{\"description\":\"list or watch objects of kind PersistentVolumeClaim\",\"operationId\":\"listCoreV1PersistentVolumeClaimForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/persistentvolumes\":{\"delete\":{\"description\":\"delete collection of PersistentVolume\",\"operationId\":\"deleteCoreV1CollectionPersistentVolume\",\"parameters\":[{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"deletecollection\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"get\":{\"description\":\"list or watch objects of kind PersistentVolume\",\"operationId\":\"listCoreV1PersistentVolume\",\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolumeList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"post\":{\"description\":\"create a PersistentVolume\",\"operationId\":\"createCoreV1PersistentVolume\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Created\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"post\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}}},\"/api/v1/persistentvolumes/{name}\":{\"delete\":{\"description\":\"delete a PersistentVolume\",\"operationId\":\"deleteCoreV1PersistentVolume\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.\",\"in\":\"query\",\"name\":\"gracePeriodSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"if set to true, it will trigger an unsafe deletion of the resource in case the normal deletion flow fails with a corrupt object error. A resource is considered corrupt if it can not be retrieved from the underlying storage successfully because of a) its data can not be transformed e.g. decryption failure, or b) it fails to decode into an object. NOTE: unsafe deletion ignores finalizer constraints, skips precondition checks, and removes the object from the storage. WARNING: This may potentially break the cluster if the workload associated with the resource being unsafe-deleted relies on normal deletion flow. Use only if you REALLY know what you are doing. The default value is false, and the user must opt in to enable it\",\"in\":\"query\",\"name\":\"ignoreStoreReadErrorWithClusterBreakingPotential\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \\\"orphan\\\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.\",\"in\":\"query\",\"name\":\"orphanDependents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.\",\"in\":\"query\",\"name\":\"propagationPolicy\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions\"}}}},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"OK\"},\"202\":{\"content\":{\"application/cbor\":{\"schema\":{}},\"application/json\":{\"schema\":{}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{}},\"application/yaml\":{\"schema\":{}}},\"description\":\"Accepted\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"delete\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"get\":{\"description\":\"read the specified PersistentVolume\",\"operationId\":\"readCoreV1PersistentVolume\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"name of the PersistentVolume\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update the specified PersistentVolume\",\"operationId\":\"patchCoreV1PersistentVolume\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace the specified PersistentVolume\",\"operationId\":\"replaceCoreV1PersistentVolume\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}}},\"/api/v1/persistentvolumes/{name}/status\":{\"get\":{\"description\":\"read status of the specified PersistentVolume\",\"operationId\":\"readCoreV1PersistentVolumeStatus\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"get\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"name of the PersistentVolume\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"patch\":{\"description\":\"partially update status of the specified PersistentVolume\",\"operationId\":\"patchCoreV1PersistentVolumeStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"Force is going to \\\"force\\\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.\",\"in\":\"query\",\"name\":\"force\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/apply-patch+cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/apply-patch+yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/json-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch\"}},\"application/merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}},\"application/strategic-merge-patch+json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"patch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"put\":{\"description\":\"replace status of the specified PersistentVolume\",\"operationId\":\"replaceCoreV1PersistentVolumeStatus\",\"parameters\":[{\"description\":\"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed\",\"in\":\"query\",\"name\":\"dryRun\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.\",\"in\":\"query\",\"name\":\"fieldManager\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.\",\"in\":\"query\",\"name\":\"fieldValidation\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}],\"requestBody\":{\"content\":{\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"required\":true},\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"OK\"},\"201\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PersistentVolume\"}}},\"description\":\"Created\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"put\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}}},\"/api/v1/pods\":{\"get\":{\"description\":\"list or watch objects of kind Pod\",\"operationId\":\"listCoreV1PodForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/podtemplates\":{\"get\":{\"description\":\"list or watch objects of kind PodTemplate\",\"operationId\":\"listCoreV1PodTemplateForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.PodTemplateList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/replicationcontrollers\":{\"get\":{\"description\":\"list or watch objects of kind ReplicationController\",\"operationId\":\"listCoreV1ReplicationControllerForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ReplicationControllerList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/resourcequotas\":{\"get\":{\"description\":\"list or watch objects of kind ResourceQuota\",\"operationId\":\"listCoreV1ResourceQuotaForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ResourceQuotaList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/secrets\":{\"get\":{\"description\":\"list or watch objects of kind Secret\",\"operationId\":\"listCoreV1SecretForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.SecretList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/serviceaccounts\":{\"get\":{\"description\":\"list or watch objects of kind ServiceAccount\",\"operationId\":\"listCoreV1ServiceAccountForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceAccountList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/services\":{\"get\":{\"description\":\"list or watch objects of kind Service\",\"operationId\":\"listCoreV1ServiceForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.api.core.v1.ServiceList\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"list\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/configmaps\":{\"get\":{\"description\":\"watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1ConfigMapListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/endpoints\":{\"get\":{\"description\":\"watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1EndpointsListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/events\":{\"get\":{\"description\":\"watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1EventListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/limitranges\":{\"get\":{\"description\":\"watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1LimitRangeListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces\":{\"get\":{\"description\":\"watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespaceList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/configmaps\":{\"get\":{\"description\":\"watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedConfigMapList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/configmaps/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedConfigMap\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ConfigMap\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ConfigMap\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/endpoints\":{\"get\":{\"description\":\"watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedEndpointsList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/endpoints/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedEndpoints\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Endpoints\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Endpoints\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/events\":{\"get\":{\"description\":\"watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedEventList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/events/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedEvent\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Event\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Event\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/limitranges\":{\"get\":{\"description\":\"watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedLimitRangeList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/limitranges/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedLimitRange\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"LimitRange\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the LimitRange\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims\":{\"get\":{\"description\":\"watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedPersistentVolumeClaimList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedPersistentVolumeClaim\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the PersistentVolumeClaim\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/pods\":{\"get\":{\"description\":\"watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedPodList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/pods/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedPod\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Pod\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/podtemplates\":{\"get\":{\"description\":\"watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedPodTemplateList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/podtemplates/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedPodTemplate\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the PodTemplate\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/replicationcontrollers\":{\"get\":{\"description\":\"watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedReplicationControllerList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedReplicationController\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ReplicationController\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/resourcequotas\":{\"get\":{\"description\":\"watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedResourceQuotaList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedResourceQuota\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ResourceQuota\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/secrets\":{\"get\":{\"description\":\"watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedSecretList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/secrets/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedSecret\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Secret\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/serviceaccounts\":{\"get\":{\"description\":\"watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedServiceAccountList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedServiceAccount\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the ServiceAccount\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/services\":{\"get\":{\"description\":\"watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NamespacedServiceList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{namespace}/services/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1NamespacedService\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Service\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"object name and auth scope, such as for teams and projects\",\"in\":\"path\",\"name\":\"namespace\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/namespaces/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1Namespace\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Namespace\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Namespace\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/nodes\":{\"get\":{\"description\":\"watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1NodeList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/nodes/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1Node\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Node\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the Node\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/persistentvolumeclaims\":{\"get\":{\"description\":\"watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1PersistentVolumeClaimListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolumeClaim\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/persistentvolumes\":{\"get\":{\"description\":\"watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1PersistentVolumeList\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/persistentvolumes/{name}\":{\"get\":{\"description\":\"watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\",\"operationId\":\"watchCoreV1PersistentVolume\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watch\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PersistentVolume\",\"version\":\"v1\"},\"parameters\":[{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}}]},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"name of the PersistentVolume\",\"in\":\"path\",\"name\":\"name\",\"required\":true,\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/pods\":{\"get\":{\"description\":\"watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1PodListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Pod\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/podtemplates\":{\"get\":{\"description\":\"watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1PodTemplateListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"PodTemplate\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/replicationcontrollers\":{\"get\":{\"description\":\"watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1ReplicationControllerListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ReplicationController\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/resourcequotas\":{\"get\":{\"description\":\"watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1ResourceQuotaListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ResourceQuota\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/secrets\":{\"get\":{\"description\":\"watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1SecretListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Secret\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/serviceaccounts\":{\"get\":{\"description\":\"watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1ServiceAccountListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"ServiceAccount\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]},\"/api/v1/watch/services\":{\"get\":{\"description\":\"watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.\",\"operationId\":\"watchCoreV1ServiceListForAllNamespaces\",\"responses\":{\"200\":{\"content\":{\"application/cbor\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/cbor-seq\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/json;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/vnd.kubernetes.protobuf;stream=watch\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}},\"application/yaml\":{\"schema\":{\"\$ref\":\"https://openapi.invalid/schema/root-a1b7b568883e44149862.json#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent\"}}},\"description\":\"OK\"},\"401\":{\"description\":\"Unauthorized\"}},\"tags\":[\"core_v1\"],\"x-kubernetes-action\":\"watchlist\",\"x-kubernetes-group-version-kind\":{\"group\":\"\",\"kind\":\"Service\",\"version\":\"v1\"}},\"parameters\":[{\"description\":\"allowWatchBookmarks requests watch events with type \\\"BOOKMARK\\\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.\",\"in\":\"query\",\"name\":\"allowWatchBookmarks\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \\\"next key\\\".\\n\\nThis field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.\",\"in\":\"query\",\"name\":\"continue\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their fields. Defaults to everything.\",\"in\":\"query\",\"name\":\"fieldSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"A selector to restrict the list of returned objects by their labels. Defaults to everything.\",\"in\":\"query\",\"name\":\"labelSelector\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.\\n\\nThe server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.\",\"in\":\"query\",\"name\":\"limit\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).\",\"in\":\"query\",\"name\":\"pretty\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersion\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.\\n\\nDefaults to unset\",\"in\":\"query\",\"name\":\"resourceVersionMatch\",\"schema\":{\"type\":\"string\",\"uniqueItems\":true}},{\"description\":\"`sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \\\"Bookmark\\\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\\\"k8s.io/initial-events-end\\\": \\\"true\\\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched.\\n\\nWhen `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan\\n is interpreted as \\\"data at least as new as the provided `resourceVersion`\\\"\\n and the bookmark event is send when the state is synced\\n to a `resourceVersion` at least as fresh as the one provided by the ListOptions.\\n If `resourceVersion` is unset, this is interpreted as \\\"consistent read\\\" and the\\n bookmark event is send when the state is synced at least to the moment\\n when request started being processed.\\n- `resourceVersionMatch` set to any other value or unset\\n Invalid error is returned.\\n\\nDefaults to true if `resourceVersion=\\\"\\\"` or `resourceVersion=\\\"0\\\"` (for backward compatibility reasons) and to false otherwise.\",\"in\":\"query\",\"name\":\"sendInitialEvents\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}},{\"description\":\"Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.\",\"in\":\"query\",\"name\":\"timeoutSeconds\",\"schema\":{\"type\":\"integer\",\"uniqueItems\":true}},{\"description\":\"Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.\",\"in\":\"query\",\"name\":\"watch\",\"schema\":{\"type\":\"boolean\",\"uniqueItems\":true}}]}}}"), +] +const _SCHEMA_ROOT_DATA = Any[ + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequest", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AttachedVolume", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Binding", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClientIPConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatusList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerImage", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerState", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateRunning", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerUser", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DaemonEndpoint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointAddress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointPort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointSubset", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Endpoints", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointsList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Event", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSeries", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostIP", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRange", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LinuxContainerUser", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Namespace", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Node", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAddress", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeFeatures", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSwapStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSystemInfo", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolume", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Pod", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodIP", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplate", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationController", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceHealth", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuota", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopeSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Service", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccount", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServicePort", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceSpec", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Taint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMountStatus", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.policy.v1.Eviction", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Time", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/text~1plain/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/requestBody/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/12/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/11/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1cbor-seq/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1cbor/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1json/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1json;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1yaml/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/0/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/1/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/10/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/2/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/3/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/4/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/5/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/6/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/7/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/8/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), + (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/9/schema", dialect = SchemaEngine.Dialect(:draft4, "http://json-schema.org/draft-04/schema", "id", false, false, false, false, false, true, true)), +] +const _SCHEMA_DIALECT_DATA = Any[ +] +const _SCHEMA_DIRECTIONAL_REQUIRED = Any[ +] + +const _SPEC = Runtime.Spec(; + security_schemes = _SECURITY_SCHEMES, + resources = _SCHEMA_RESOURCE_DATA, + roots = _SCHEMA_ROOT_DATA, + dialects = _SCHEMA_DIALECT_DATA, + directional_required = _SCHEMA_DIRECTIONAL_REQUIRED, + default_server = "http://127.0.0.1:8080", +) + +const SERVER = _SPEC.server + +Client(server::Union{Nothing,AbstractString} = nothing; kwargs...) = + Runtime.Client(_SPEC, server; kwargs...) +const DEFAULT_CLIENT = Runtime.Client(_SPEC; _default = true) + +credential!(client::Runtime.Client, name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(client, name, credential) +credential!(name::AbstractString, credential::AbstractCredential) = + Runtime.credential!(DEFAULT_CLIENT, name, credential) +clearcredential!(client::Runtime.Client, name::AbstractString) = + Runtime.clearcredential!(client, name) +clearcredential!(name::AbstractString) = Runtime.clearcredential!(DEFAULT_CLIENT, name) +server!(client::Runtime.Client, server::Union{Nothing,AbstractString}) = + Runtime.server!(client, server) +server!(server::Union{Nothing,AbstractString}) = Runtime.server!(DEFAULT_CLIENT, server) +server_index!(client::Runtime.Client, index::Integer) = Runtime.server_index!(client, index) +server_index!(index::Integer) = Runtime.server_index!(DEFAULT_CLIENT, index) +server_name!(client::Runtime.Client, name::Union{Nothing,AbstractString}) = + Runtime.server_name!(client, name) +server_name!(name::Union{Nothing,AbstractString}) = Runtime.server_name!(DEFAULT_CLIENT, name) +server_variable!(client::Runtime.Client, name::AbstractString, value::AbstractString) = + Runtime.server_variable!(client, name, value) +server_variable!(name::AbstractString, value::AbstractString) = + Runtime.server_variable!(DEFAULT_CLIENT, name, value) +codec!(client::Runtime.Client, media_type::AbstractString; kwargs...) = + Runtime.codec!(client, media_type; kwargs...) +codec!(media_type::AbstractString; kwargs...) = + Runtime.codec!(DEFAULT_CLIENT, media_type; kwargs...) +authorization!(client::Runtime.Client, token::Union{Nothing,AbstractString}) = + Runtime.authorization!(client, token) +authorization!(token::Union{Nothing,AbstractString}) = + Runtime.authorization!(DEFAULT_CLIENT, token) + +Base.@kwdef struct IoK8sApiAuthenticationV1BoundObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAuthenticationV1BoundObjectReference}, value) = _decode(IoK8sApiAuthenticationV1BoundObjectReference, value, true) +function _decode(::Type{IoK8sApiAuthenticationV1BoundObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference"), _openapi_raw, "decoding IoK8sApiAuthenticationV1BoundObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAuthenticationV1BoundObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAuthenticationV1BoundObjectReference(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAuthenticationV1BoundObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.BoundObjectReference"), _openapi_output, "encoding IoK8sApiAuthenticationV1BoundObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAuthenticationV1BoundObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/annotations"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1Time = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta/properties/labels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1FieldsV1 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, value) = _decode(IoK8sApimachineryPkgApisMetaV1FieldsV1, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1FieldsV1}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1FieldsV1") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1FieldsV1(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1FieldsV1"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1FieldsV1) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldstype::Union{Absent,Nothing,String} = ABSENT + fieldsv1::Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing} = ABSENT + manager::Union{Absent,Nothing,String} = ABSENT + operation::Union{Absent,Nothing,String} = ABSENT + subresource::Union{Absent,Nothing,String} = ABSENT + time::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldstype = haskey(_openapi_object, "fieldsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldsType"], _openapi_validate) : ABSENT + _openapi_field_fieldsv1 = haskey(_openapi_object, "fieldsV1") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1FieldsV1,Nothing}, _openapi_object["fieldsV1"], _openapi_validate) : ABSENT + _openapi_field_manager = haskey(_openapi_object, "manager") ? _decode(Union{Absent,Nothing,String}, _openapi_object["manager"], _openapi_validate) : ABSENT + _openapi_field_operation = haskey(_openapi_object, "operation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operation"], _openapi_validate) : ABSENT + _openapi_field_subresource = haskey(_openapi_object, "subresource") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subresource"], _openapi_validate) : ABSENT + _openapi_field_time = haskey(_openapi_object, "time") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["time"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldsType","fieldsV1","manager","operation","subresource","time") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry(; apiversion = _openapi_field_apiversion, fieldstype = _openapi_field_fieldstype, fieldsv1 = _openapi_field_fieldsv1, manager = _openapi_field_manager, operation = _openapi_field_operation, subresource = _openapi_field_subresource, time = _openapi_field_time, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldstype isa Absent || (_openapi_output["fieldsType"] = _encode(_openapi_value.fieldstype)) + _openapi_value.fieldsv1 isa Absent || (_openapi_output["fieldsV1"] = _encode(_openapi_value.fieldsv1)) + _openapi_value.manager isa Absent || (_openapi_output["manager"] = _encode(_openapi_value.manager)) + _openapi_value.operation isa Absent || (_openapi_output["operation"] = _encode(_openapi_value.operation)) + _openapi_value.subresource isa Absent || (_openapi_output["subresource"] = _encode(_openapi_value.subresource)) + _openapi_value.time isa Absent || (_openapi_output["time"] = _encode(_openapi_value.time)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldstype isa Absent || push!(_openapi_output, "fieldsType" => _openapi_value.fieldstype) + _openapi_value.fieldsv1 isa Absent || push!(_openapi_output, "fieldsV1" => _openapi_value.fieldsv1) + _openapi_value.manager isa Absent || push!(_openapi_output, "manager" => _openapi_value.manager) + _openapi_value.operation isa Absent || push!(_openapi_output, "operation" => _openapi_value.operation) + _openapi_value.subresource isa Absent || push!(_openapi_output, "subresource" => _openapi_value.subresource) + _openapi_value.time isa Absent || push!(_openapi_output, "time" => _openapi_value.time) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1OwnerReference + apiversion::String + blockownerdeletion::Union{Absent,Bool,Nothing} = ABSENT + controller::Union{Absent,Bool,Nothing} = ABSENT + kind::String + name::String + uid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, value) = _decode(IoK8sApimachineryPkgApisMetaV1OwnerReference, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1OwnerReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1OwnerReference") + _openapi_field_apiversion = _decode(String, _required(_openapi_object, "apiVersion", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_blockownerdeletion = haskey(_openapi_object, "blockOwnerDeletion") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["blockOwnerDeletion"], _openapi_validate) : ABSENT + _openapi_field_controller = haskey(_openapi_object, "controller") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["controller"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_field_uid = _decode(String, _required(_openapi_object, "uid", "IoK8sApimachineryPkgApisMetaV1OwnerReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","blockOwnerDeletion","controller","kind","name","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1OwnerReference(; apiversion = _openapi_field_apiversion, blockownerdeletion = _openapi_field_blockownerdeletion, controller = _openapi_field_controller, kind = _openapi_field_kind, name = _openapi_field_name, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.blockownerdeletion isa Absent || (_openapi_output["blockOwnerDeletion"] = _encode(_openapi_value.blockownerdeletion)) + _openapi_value.controller isa Absent || (_openapi_output["controller"] = _encode(_openapi_value.controller)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1OwnerReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1OwnerReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.blockownerdeletion isa Absent || push!(_openapi_output, "blockOwnerDeletion" => _openapi_value.blockownerdeletion) + _openapi_value.controller isa Absent || push!(_openapi_output, "controller" => _openapi_value.controller) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ObjectMeta + annotations::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing} = ABSENT + creationtimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + deletiongraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + deletiontimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + generatename::Union{Absent,Nothing,String} = ABSENT + generation::Union{Absent,Int64,Nothing} = ABSENT + labels::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing} = ABSENT + managedfields::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + ownerreferences::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ObjectMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ObjectMeta") + _openapi_field_annotations = haskey(_openapi_object, "annotations") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaAnnotations,Nothing}, _openapi_object["annotations"], _openapi_validate) : ABSENT + _openapi_field_creationtimestamp = haskey(_openapi_object, "creationTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["creationTimestamp"], _openapi_validate) : ABSENT + _openapi_field_deletiongraceperiodseconds = haskey(_openapi_object, "deletionGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["deletionGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_deletiontimestamp = haskey(_openapi_object, "deletionTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["deletionTimestamp"], _openapi_validate) : ABSENT + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_field_generatename = haskey(_openapi_object, "generateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["generateName"], _openapi_validate) : ABSENT + _openapi_field_generation = haskey(_openapi_object, "generation") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["generation"], _openapi_validate) : ABSENT + _openapi_field_labels = haskey(_openapi_object, "labels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMetaLabels,Nothing}, _openapi_object["labels"], _openapi_validate) : ABSENT + _openapi_field_managedfields = haskey(_openapi_object, "managedFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1ManagedFieldsEntry}}}, _openapi_object["managedFields"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_ownerreferences = haskey(_openapi_object, "ownerReferences") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1OwnerReference}}}, _openapi_object["ownerReferences"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("annotations","creationTimestamp","deletionGracePeriodSeconds","deletionTimestamp","finalizers","generateName","generation","labels","managedFields","name","namespace","ownerReferences","resourceVersion","selfLink","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ObjectMeta(; annotations = _openapi_field_annotations, creationtimestamp = _openapi_field_creationtimestamp, deletiongraceperiodseconds = _openapi_field_deletiongraceperiodseconds, deletiontimestamp = _openapi_field_deletiontimestamp, finalizers = _openapi_field_finalizers, generatename = _openapi_field_generatename, generation = _openapi_field_generation, labels = _openapi_field_labels, managedfields = _openapi_field_managedfields, name = _openapi_field_name, namespace = _openapi_field_namespace, ownerreferences = _openapi_field_ownerreferences, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.annotations isa Absent || (_openapi_output["annotations"] = _encode(_openapi_value.annotations)) + _openapi_value.creationtimestamp isa Absent || (_openapi_output["creationTimestamp"] = _encode(_openapi_value.creationtimestamp)) + _openapi_value.deletiongraceperiodseconds isa Absent || (_openapi_output["deletionGracePeriodSeconds"] = _encode(_openapi_value.deletiongraceperiodseconds)) + _openapi_value.deletiontimestamp isa Absent || (_openapi_output["deletionTimestamp"] = _encode(_openapi_value.deletiontimestamp)) + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + _openapi_value.generatename isa Absent || (_openapi_output["generateName"] = _encode(_openapi_value.generatename)) + _openapi_value.generation isa Absent || (_openapi_output["generation"] = _encode(_openapi_value.generation)) + _openapi_value.labels isa Absent || (_openapi_output["labels"] = _encode(_openapi_value.labels)) + _openapi_value.managedfields isa Absent || (_openapi_output["managedFields"] = _encode(_openapi_value.managedfields)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.ownerreferences isa Absent || (_openapi_output["ownerReferences"] = _encode(_openapi_value.ownerreferences)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ObjectMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ObjectMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.annotations isa Absent || push!(_openapi_output, "annotations" => _openapi_value.annotations) + _openapi_value.creationtimestamp isa Absent || push!(_openapi_output, "creationTimestamp" => _openapi_value.creationtimestamp) + _openapi_value.deletiongraceperiodseconds isa Absent || push!(_openapi_output, "deletionGracePeriodSeconds" => _openapi_value.deletiongraceperiodseconds) + _openapi_value.deletiontimestamp isa Absent || push!(_openapi_output, "deletionTimestamp" => _openapi_value.deletiontimestamp) + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + _openapi_value.generatename isa Absent || push!(_openapi_output, "generateName" => _openapi_value.generatename) + _openapi_value.generation isa Absent || push!(_openapi_output, "generation" => _openapi_value.generation) + _openapi_value.labels isa Absent || push!(_openapi_output, "labels" => _openapi_value.labels) + _openapi_value.managedfields isa Absent || push!(_openapi_output, "managedFields" => _openapi_value.managedfields) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.ownerreferences isa Absent || push!(_openapi_output, "ownerReferences" => _openapi_value.ownerreferences) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAuthenticationV1TokenRequestSpec + audiences::Union{Nothing,Vector{String}} + boundobjectref::Union{Absent,IoK8sApiAuthenticationV1BoundObjectReference,Nothing} = ABSENT + expirationseconds::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAuthenticationV1TokenRequestSpec}, value) = _decode(IoK8sApiAuthenticationV1TokenRequestSpec, value, true) +function _decode(::Type{IoK8sApiAuthenticationV1TokenRequestSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec"), _openapi_raw, "decoding IoK8sApiAuthenticationV1TokenRequestSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAuthenticationV1TokenRequestSpec") + _openapi_field_audiences = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "audiences", "IoK8sApiAuthenticationV1TokenRequestSpec"), _openapi_validate) + _openapi_field_boundobjectref = haskey(_openapi_object, "boundObjectRef") ? _decode(Union{Absent,IoK8sApiAuthenticationV1BoundObjectReference,Nothing}, _openapi_object["boundObjectRef"], _openapi_validate) : ABSENT + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("audiences","boundObjectRef","expirationSeconds") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAuthenticationV1TokenRequestSpec(; audiences = _openapi_field_audiences, boundobjectref = _openapi_field_boundobjectref, expirationseconds = _openapi_field_expirationseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAuthenticationV1TokenRequestSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.audiences isa Absent || (_openapi_output["audiences"] = _encode(_openapi_value.audiences)) + _openapi_value.boundobjectref isa Absent || (_openapi_output["boundObjectRef"] = _encode(_openapi_value.boundobjectref)) + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestSpec"), _openapi_output, "encoding IoK8sApiAuthenticationV1TokenRequestSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAuthenticationV1TokenRequestSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.audiences isa Absent || push!(_openapi_output, "audiences" => _openapi_value.audiences) + _openapi_value.boundobjectref isa Absent || push!(_openapi_output, "boundObjectRef" => _openapi_value.boundobjectref) + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAuthenticationV1TokenRequestStatus + expirationtimestamp::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + token::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAuthenticationV1TokenRequestStatus}, value) = _decode(IoK8sApiAuthenticationV1TokenRequestStatus, value, true) +function _decode(::Type{IoK8sApiAuthenticationV1TokenRequestStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus"), _openapi_raw, "decoding IoK8sApiAuthenticationV1TokenRequestStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAuthenticationV1TokenRequestStatus") + _openapi_field_expirationtimestamp = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "expirationTimestamp", "IoK8sApiAuthenticationV1TokenRequestStatus"), _openapi_validate) + _openapi_field_token = _decode(String, _required(_openapi_object, "token", "IoK8sApiAuthenticationV1TokenRequestStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("expirationTimestamp","token") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAuthenticationV1TokenRequestStatus(; expirationtimestamp = _openapi_field_expirationtimestamp, token = _openapi_field_token, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAuthenticationV1TokenRequestStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.expirationtimestamp isa Absent || (_openapi_output["expirationTimestamp"] = _encode(_openapi_value.expirationtimestamp)) + _openapi_value.token isa Absent || (_openapi_output["token"] = _encode(_openapi_value.token)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequestStatus"), _openapi_output, "encoding IoK8sApiAuthenticationV1TokenRequestStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAuthenticationV1TokenRequestStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.expirationtimestamp isa Absent || push!(_openapi_output, "expirationTimestamp" => _openapi_value.expirationtimestamp) + _openapi_value.token isa Absent || push!(_openapi_output, "token" => _openapi_value.token) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAuthenticationV1TokenRequest + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiAuthenticationV1TokenRequestSpec + status::Union{Absent,IoK8sApiAuthenticationV1TokenRequestStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAuthenticationV1TokenRequest}, value) = _decode(IoK8sApiAuthenticationV1TokenRequest, value, true) +function _decode(::Type{IoK8sApiAuthenticationV1TokenRequest}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequest"), _openapi_raw, "decoding IoK8sApiAuthenticationV1TokenRequest"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAuthenticationV1TokenRequest") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiAuthenticationV1TokenRequestSpec, _required(_openapi_object, "spec", "IoK8sApiAuthenticationV1TokenRequest"), _openapi_validate) + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAuthenticationV1TokenRequestStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAuthenticationV1TokenRequest(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAuthenticationV1TokenRequest) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.authentication.v1.TokenRequest"), _openapi_output, "encoding IoK8sApiAuthenticationV1TokenRequest"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAuthenticationV1TokenRequest) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1ScaleSpec + replicas::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1ScaleSpec}, value) = _decode(IoK8sApiAutoscalingV1ScaleSpec, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1ScaleSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec"), _openapi_raw, "decoding IoK8sApiAutoscalingV1ScaleSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1ScaleSpec") + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("replicas",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1ScaleSpec(; replicas = _openapi_field_replicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1ScaleSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleSpec"), _openapi_output, "encoding IoK8sApiAutoscalingV1ScaleSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1ScaleSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1ScaleStatus + replicas::Int32 + selector::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1ScaleStatus}, value) = _decode(IoK8sApiAutoscalingV1ScaleStatus, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1ScaleStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus"), _openapi_raw, "decoding IoK8sApiAutoscalingV1ScaleStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1ScaleStatus") + _openapi_field_replicas = _decode(Int32, _required(_openapi_object, "replicas", "IoK8sApiAutoscalingV1ScaleStatus"), _openapi_validate) + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("replicas","selector") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1ScaleStatus(; replicas = _openapi_field_replicas, selector = _openapi_field_selector, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1ScaleStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.ScaleStatus"), _openapi_output, "encoding IoK8sApiAutoscalingV1ScaleStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1ScaleStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiAutoscalingV1Scale + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiAutoscalingV1ScaleSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiAutoscalingV1ScaleStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiAutoscalingV1Scale}, value) = _decode(IoK8sApiAutoscalingV1Scale, value, true) +function _decode(::Type{IoK8sApiAutoscalingV1Scale}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale"), _openapi_raw, "decoding IoK8sApiAutoscalingV1Scale"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiAutoscalingV1Scale") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiAutoscalingV1ScaleSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiAutoscalingV1ScaleStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiAutoscalingV1Scale(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiAutoscalingV1Scale) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.autoscaling.v1.Scale"), _openapi_output, "encoding IoK8sApiAutoscalingV1Scale"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiAutoscalingV1Scale) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, value) = _decode(IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, value) = _decode(IoK8sApiCoreV1NodeSelectorRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1NodeSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorRequirement"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelectorTerm + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + matchfields::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, value) = _decode(IoK8sApiCoreV1NodeSelectorTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelectorTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelectorTerm") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchfields = haskey(_openapi_object, "matchFields") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorRequirement}}}, _openapi_object["matchFields"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchFields") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelectorTerm(; matchexpressions = _openapi_field_matchexpressions, matchfields = _openapi_field_matchfields, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchfields isa Absent || (_openapi_output["matchFields"] = _encode(_openapi_value.matchfields)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelectorTerm"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelectorTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelectorTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchfields isa Absent || push!(_openapi_output, "matchFields" => _openapi_value.matchfields) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PreferredSchedulingTerm + preference::IoK8sApiCoreV1NodeSelectorTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, value) = _decode(IoK8sApiCoreV1PreferredSchedulingTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PreferredSchedulingTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PreferredSchedulingTerm") + _openapi_field_preference = _decode(IoK8sApiCoreV1NodeSelectorTerm, _required(_openapi_object, "preference", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1PreferredSchedulingTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preference","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PreferredSchedulingTerm(; preference = _openapi_field_preference, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preference isa Absent || (_openapi_output["preference"] = _encode(_openapi_value.preference)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PreferredSchedulingTerm"), _openapi_output, "encoding IoK8sApiCoreV1PreferredSchedulingTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PreferredSchedulingTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.preference isa Absent || push!(_openapi_output, "preference" => _openapi_value.preference) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSelector + nodeselectorterms::Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSelector}, value) = _decode(IoK8sApiCoreV1NodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSelector") + _openapi_field_nodeselectorterms = _decode(Union{Nothing,Vector{IoK8sApiCoreV1NodeSelectorTerm}}, _required(_openapi_object, "nodeSelectorTerms", "IoK8sApiCoreV1NodeSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeSelectorTerms",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSelector(; nodeselectorterms = _openapi_field_nodeselectorterms, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeselectorterms isa Absent || (_openapi_output["nodeSelectorTerms"] = _encode(_openapi_value.nodeselectorterms)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1NodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeselectorterms isa Absent || push!(_openapi_output, "nodeSelectorTerms" => _openapi_value.nodeselectorterms) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeAffinity}, value) = _decode(IoK8sApiCoreV1NodeAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PreferredSchedulingTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAffinity"), _openapi_output, "encoding IoK8sApiCoreV1NodeAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement + key::String + operator::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement(; key = _openapi_field_key, operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector/properties/matchLabels"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1LabelSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}} = ABSENT + matchlabels::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, value) = _decode(IoK8sApimachineryPkgApisMetaV1LabelSelector, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1LabelSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1LabelSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1LabelSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_field_matchlabels = haskey(_openapi_object, "matchLabels") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelectorMatchLabels,Nothing}, _openapi_object["matchLabels"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions","matchLabels") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1LabelSelector(; matchexpressions = _openapi_field_matchexpressions, matchlabels = _openapi_field_matchlabels, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + _openapi_value.matchlabels isa Absent || (_openapi_output["matchLabels"] = _encode(_openapi_value.matchlabels)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1LabelSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1LabelSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + _openapi_value.matchlabels isa Absent || push!(_openapi_output, "matchLabels" => _openapi_value.matchlabels) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinityTerm + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + mismatchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + namespaceselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + namespaces::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + topologykey::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, value) = _decode(IoK8sApiCoreV1PodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinityTerm") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_mismatchlabelkeys = haskey(_openapi_object, "mismatchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mismatchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_namespaceselector = haskey(_openapi_object, "namespaceSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["namespaceSelector"], _openapi_validate) : ABSENT + _openapi_field_namespaces = haskey(_openapi_object, "namespaces") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["namespaces"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1PodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","mismatchLabelKeys","namespaceSelector","namespaces","topologyKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinityTerm(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, mismatchlabelkeys = _openapi_field_mismatchlabelkeys, namespaceselector = _openapi_field_namespaceselector, namespaces = _openapi_field_namespaces, topologykey = _openapi_field_topologykey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.mismatchlabelkeys isa Absent || (_openapi_output["mismatchLabelKeys"] = _encode(_openapi_value.mismatchlabelkeys)) + _openapi_value.namespaceselector isa Absent || (_openapi_output["namespaceSelector"] = _encode(_openapi_value.namespaceselector)) + _openapi_value.namespaces isa Absent || (_openapi_output["namespaces"] = _encode(_openapi_value.namespaces)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.mismatchlabelkeys isa Absent || push!(_openapi_output, "mismatchLabelKeys" => _openapi_value.mismatchlabelkeys) + _openapi_value.namespaceselector isa Absent || push!(_openapi_output, "namespaceSelector" => _openapi_value.namespaceselector) + _openapi_value.namespaces isa Absent || push!(_openapi_output, "namespaces" => _openapi_value.namespaces) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WeightedPodAffinityTerm + podaffinityterm::IoK8sApiCoreV1PodAffinityTerm + weight::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, value) = _decode(IoK8sApiCoreV1WeightedPodAffinityTerm, value, true) +function _decode(::Type{IoK8sApiCoreV1WeightedPodAffinityTerm}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_raw, "decoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WeightedPodAffinityTerm") + _openapi_field_podaffinityterm = _decode(IoK8sApiCoreV1PodAffinityTerm, _required(_openapi_object, "podAffinityTerm", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_field_weight = _decode(Int32, _required(_openapi_object, "weight", "IoK8sApiCoreV1WeightedPodAffinityTerm"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("podAffinityTerm","weight") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WeightedPodAffinityTerm(; podaffinityterm = _openapi_field_podaffinityterm, weight = _openapi_field_weight, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.podaffinityterm isa Absent || (_openapi_output["podAffinityTerm"] = _encode(_openapi_value.podaffinityterm)) + _openapi_value.weight isa Absent || (_openapi_output["weight"] = _encode(_openapi_value.weight)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WeightedPodAffinityTerm"), _openapi_output, "encoding IoK8sApiCoreV1WeightedPodAffinityTerm"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WeightedPodAffinityTerm) + _openapi_output = Pair{String,Any}[] + _openapi_value.podaffinityterm isa Absent || push!(_openapi_output, "podAffinityTerm" => _openapi_value.podaffinityterm) + _openapi_value.weight isa Absent || push!(_openapi_output, "weight" => _openapi_value.weight) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAffinity}, value) = _decode(IoK8sApiCoreV1PodAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodAntiAffinity + preferredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}} = ABSENT + requiredduringschedulingignoredduringexecution::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, value) = _decode(IoK8sApiCoreV1PodAntiAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1PodAntiAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodAntiAffinity") + _openapi_field_preferredduringschedulingignoredduringexecution = haskey(_openapi_object, "preferredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1WeightedPodAffinityTerm}}}, _openapi_object["preferredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_field_requiredduringschedulingignoredduringexecution = haskey(_openapi_object, "requiredDuringSchedulingIgnoredDuringExecution") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodAffinityTerm}}}, _openapi_object["requiredDuringSchedulingIgnoredDuringExecution"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("preferredDuringSchedulingIgnoredDuringExecution","requiredDuringSchedulingIgnoredDuringExecution") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodAntiAffinity(; preferredduringschedulingignoredduringexecution = _openapi_field_preferredduringschedulingignoredduringexecution, requiredduringschedulingignoredduringexecution = _openapi_field_requiredduringschedulingignoredduringexecution, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || (_openapi_output["preferredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.preferredduringschedulingignoredduringexecution)) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || (_openapi_output["requiredDuringSchedulingIgnoredDuringExecution"] = _encode(_openapi_value.requiredduringschedulingignoredduringexecution)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodAntiAffinity"), _openapi_output, "encoding IoK8sApiCoreV1PodAntiAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodAntiAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.preferredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "preferredDuringSchedulingIgnoredDuringExecution" => _openapi_value.preferredduringschedulingignoredduringexecution) + _openapi_value.requiredduringschedulingignoredduringexecution isa Absent || push!(_openapi_output, "requiredDuringSchedulingIgnoredDuringExecution" => _openapi_value.requiredduringschedulingignoredduringexecution) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Affinity + nodeaffinity::Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing} = ABSENT + podaffinity::Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing} = ABSENT + podantiaffinity::Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Affinity}, value) = _decode(IoK8sApiCoreV1Affinity, value, true) +function _decode(::Type{IoK8sApiCoreV1Affinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_raw, "decoding IoK8sApiCoreV1Affinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Affinity") + _openapi_field_nodeaffinity = haskey(_openapi_object, "nodeAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1NodeAffinity,Nothing}, _openapi_object["nodeAffinity"], _openapi_validate) : ABSENT + _openapi_field_podaffinity = haskey(_openapi_object, "podAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAffinity,Nothing}, _openapi_object["podAffinity"], _openapi_validate) : ABSENT + _openapi_field_podantiaffinity = haskey(_openapi_object, "podAntiAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1PodAntiAffinity,Nothing}, _openapi_object["podAntiAffinity"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nodeAffinity","podAffinity","podAntiAffinity") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Affinity(; nodeaffinity = _openapi_field_nodeaffinity, podaffinity = _openapi_field_podaffinity, podantiaffinity = _openapi_field_podantiaffinity, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nodeaffinity isa Absent || (_openapi_output["nodeAffinity"] = _encode(_openapi_value.nodeaffinity)) + _openapi_value.podaffinity isa Absent || (_openapi_output["podAffinity"] = _encode(_openapi_value.podaffinity)) + _openapi_value.podantiaffinity isa Absent || (_openapi_output["podAntiAffinity"] = _encode(_openapi_value.podantiaffinity)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Affinity"), _openapi_output, "encoding IoK8sApiCoreV1Affinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Affinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.nodeaffinity isa Absent || push!(_openapi_output, "nodeAffinity" => _openapi_value.nodeaffinity) + _openapi_value.podaffinity isa Absent || push!(_openapi_output, "podAffinity" => _openapi_value.podaffinity) + _openapi_value.podantiaffinity isa Absent || push!(_openapi_output, "podAntiAffinity" => _openapi_value.podantiaffinity) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AppArmorProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AppArmorProfile}, value) = _decode(IoK8sApiCoreV1AppArmorProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1AppArmorProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_raw, "decoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AppArmorProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1AppArmorProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AppArmorProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AppArmorProfile"), _openapi_output, "encoding IoK8sApiCoreV1AppArmorProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AppArmorProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AttachedVolume + devicepath::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AttachedVolume}, value) = _decode(IoK8sApiCoreV1AttachedVolume, value, true) +function _decode(::Type{IoK8sApiCoreV1AttachedVolume}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AttachedVolume"), _openapi_raw, "decoding IoK8sApiCoreV1AttachedVolume"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AttachedVolume") + _openapi_field_devicepath = _decode(String, _required(_openapi_object, "devicePath", "IoK8sApiCoreV1AttachedVolume"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1AttachedVolume"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("devicePath","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AttachedVolume(; devicepath = _openapi_field_devicepath, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AttachedVolume) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.devicepath isa Absent || (_openapi_output["devicePath"] = _encode(_openapi_value.devicepath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AttachedVolume"), _openapi_output, "encoding IoK8sApiCoreV1AttachedVolume"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AttachedVolume) + _openapi_output = Pair{String,Any}[] + _openapi_value.devicepath isa Absent || push!(_openapi_output, "devicePath" => _openapi_value.devicepath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureDiskVolumeSource + cachingmode::Union{Absent,Nothing,String} = ABSENT + diskname::String + diskuri::String + fstype::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureDiskVolumeSource") + _openapi_field_cachingmode = haskey(_openapi_object, "cachingMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["cachingMode"], _openapi_validate) : ABSENT + _openapi_field_diskname = _decode(String, _required(_openapi_object, "diskName", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_diskuri = _decode(String, _required(_openapi_object, "diskURI", "IoK8sApiCoreV1AzureDiskVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("cachingMode","diskName","diskURI","fsType","kind","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureDiskVolumeSource(; cachingmode = _openapi_field_cachingmode, diskname = _openapi_field_diskname, diskuri = _openapi_field_diskuri, fstype = _openapi_field_fstype, kind = _openapi_field_kind, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.cachingmode isa Absent || (_openapi_output["cachingMode"] = _encode(_openapi_value.cachingmode)) + _openapi_value.diskname isa Absent || (_openapi_output["diskName"] = _encode(_openapi_value.diskname)) + _openapi_value.diskuri isa Absent || (_openapi_output["diskURI"] = _encode(_openapi_value.diskuri)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.cachingmode isa Absent || push!(_openapi_output, "cachingMode" => _openapi_value.cachingmode) + _openapi_value.diskname isa Absent || push!(_openapi_output, "diskName" => _openapi_value.diskname) + _openapi_value.diskuri isa Absent || push!(_openapi_output, "diskURI" => _openapi_value.diskuri) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureFilePersistentVolumeSource + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretname::String + secretnamespace::Union{Absent,Nothing,String} = ABSENT + sharename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureFilePersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureFilePersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureFilePersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureFilePersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureFilePersistentVolumeSource") + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretname = _decode(String, _required(_openapi_object, "secretName", "IoK8sApiCoreV1AzureFilePersistentVolumeSource"), _openapi_validate) + _openapi_field_secretnamespace = haskey(_openapi_object, "secretNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretNamespace"], _openapi_validate) : ABSENT + _openapi_field_sharename = _decode(String, _required(_openapi_object, "shareName", "IoK8sApiCoreV1AzureFilePersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("readOnly","secretName","secretNamespace","shareName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureFilePersistentVolumeSource(; readonly = _openapi_field_readonly, secretname = _openapi_field_secretname, secretnamespace = _openapi_field_secretnamespace, sharename = _openapi_field_sharename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureFilePersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + _openapi_value.secretnamespace isa Absent || (_openapi_output["secretNamespace"] = _encode(_openapi_value.secretnamespace)) + _openapi_value.sharename isa Absent || (_openapi_output["shareName"] = _encode(_openapi_value.sharename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFilePersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureFilePersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureFilePersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + _openapi_value.secretnamespace isa Absent || push!(_openapi_output, "secretNamespace" => _openapi_value.secretnamespace) + _openapi_value.sharename isa Absent || push!(_openapi_output, "shareName" => _openapi_value.sharename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1AzureFileVolumeSource + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretname::String + sharename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, value) = _decode(IoK8sApiCoreV1AzureFileVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1AzureFileVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1AzureFileVolumeSource") + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretname = _decode(String, _required(_openapi_object, "secretName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_field_sharename = _decode(String, _required(_openapi_object, "shareName", "IoK8sApiCoreV1AzureFileVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("readOnly","secretName","shareName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1AzureFileVolumeSource(; readonly = _openapi_field_readonly, secretname = _openapi_field_secretname, sharename = _openapi_field_sharename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + _openapi_value.sharename isa Absent || (_openapi_output["shareName"] = _encode(_openapi_value.sharename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.AzureFileVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1AzureFileVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1AzureFileVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + _openapi_value.sharename isa Absent || push!(_openapi_output, "shareName" => _openapi_value.sharename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectReference + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectReference}, value) = _decode(IoK8sApiCoreV1ObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectReference") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = haskey(_openapi_object, "fieldPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fieldPath"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath","kind","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectReference(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1ObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Binding + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + target::IoK8sApiCoreV1ObjectReference + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Binding}, value) = _decode(IoK8sApiCoreV1Binding, value, true) +function _decode(::Type{IoK8sApiCoreV1Binding}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Binding"), _openapi_raw, "decoding IoK8sApiCoreV1Binding"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Binding") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_target = _decode(IoK8sApiCoreV1ObjectReference, _required(_openapi_object, "target", "IoK8sApiCoreV1Binding"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","target") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Binding(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, target = _openapi_field_target, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Binding) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.target isa Absent || (_openapi_output["target"] = _encode(_openapi_value.target)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Binding"), _openapi_output, "encoding IoK8sApiCoreV1Binding"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Binding) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.target isa Absent || push!(_openapi_output, "target" => _openapi_value.target) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretReference + name::Union{Absent,Nothing,String} = ABSENT + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretReference}, value) = _decode(IoK8sApiCoreV1SecretReference, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference"), _openapi_raw, "decoding IoK8sApiCoreV1SecretReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretReference(; name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretReference"), _openapi_output, "encoding IoK8sApiCoreV1SecretReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes}, value) = _decode(IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource/properties/volumeAttributes"), _openapi_raw, "decoding IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource/properties/volumeAttributes"), _openapi_output, "encoding IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIPersistentVolumeSource + controllerexpandsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + controllerpublishsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + nodeexpandsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + nodepublishsecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + nodestagesecretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeattributes::Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes,Nothing} = ABSENT + volumehandle::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CSIPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CSIPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIPersistentVolumeSource") + _openapi_field_controllerexpandsecretref = haskey(_openapi_object, "controllerExpandSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["controllerExpandSecretRef"], _openapi_validate) : ABSENT + _openapi_field_controllerpublishsecretref = haskey(_openapi_object, "controllerPublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["controllerPublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1CSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_nodeexpandsecretref = haskey(_openapi_object, "nodeExpandSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodeExpandSecretRef"], _openapi_validate) : ABSENT + _openapi_field_nodepublishsecretref = haskey(_openapi_object, "nodePublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodePublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_nodestagesecretref = haskey(_openapi_object, "nodeStageSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["nodeStageSecretRef"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeattributes = haskey(_openapi_object, "volumeAttributes") ? _decode(Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSourceVolumeAttributes,Nothing}, _openapi_object["volumeAttributes"], _openapi_validate) : ABSENT + _openapi_field_volumehandle = _decode(String, _required(_openapi_object, "volumeHandle", "IoK8sApiCoreV1CSIPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("controllerExpandSecretRef","controllerPublishSecretRef","driver","fsType","nodeExpandSecretRef","nodePublishSecretRef","nodeStageSecretRef","readOnly","volumeAttributes","volumeHandle") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIPersistentVolumeSource(; controllerexpandsecretref = _openapi_field_controllerexpandsecretref, controllerpublishsecretref = _openapi_field_controllerpublishsecretref, driver = _openapi_field_driver, fstype = _openapi_field_fstype, nodeexpandsecretref = _openapi_field_nodeexpandsecretref, nodepublishsecretref = _openapi_field_nodepublishsecretref, nodestagesecretref = _openapi_field_nodestagesecretref, readonly = _openapi_field_readonly, volumeattributes = _openapi_field_volumeattributes, volumehandle = _openapi_field_volumehandle, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.controllerexpandsecretref isa Absent || (_openapi_output["controllerExpandSecretRef"] = _encode(_openapi_value.controllerexpandsecretref)) + _openapi_value.controllerpublishsecretref isa Absent || (_openapi_output["controllerPublishSecretRef"] = _encode(_openapi_value.controllerpublishsecretref)) + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.nodeexpandsecretref isa Absent || (_openapi_output["nodeExpandSecretRef"] = _encode(_openapi_value.nodeexpandsecretref)) + _openapi_value.nodepublishsecretref isa Absent || (_openapi_output["nodePublishSecretRef"] = _encode(_openapi_value.nodepublishsecretref)) + _openapi_value.nodestagesecretref isa Absent || (_openapi_output["nodeStageSecretRef"] = _encode(_openapi_value.nodestagesecretref)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeattributes isa Absent || (_openapi_output["volumeAttributes"] = _encode(_openapi_value.volumeattributes)) + _openapi_value.volumehandle isa Absent || (_openapi_output["volumeHandle"] = _encode(_openapi_value.volumehandle)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CSIPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.controllerexpandsecretref isa Absent || push!(_openapi_output, "controllerExpandSecretRef" => _openapi_value.controllerexpandsecretref) + _openapi_value.controllerpublishsecretref isa Absent || push!(_openapi_output, "controllerPublishSecretRef" => _openapi_value.controllerpublishsecretref) + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.nodeexpandsecretref isa Absent || push!(_openapi_output, "nodeExpandSecretRef" => _openapi_value.nodeexpandsecretref) + _openapi_value.nodepublishsecretref isa Absent || push!(_openapi_output, "nodePublishSecretRef" => _openapi_value.nodepublishsecretref) + _openapi_value.nodestagesecretref isa Absent || push!(_openapi_output, "nodeStageSecretRef" => _openapi_value.nodestagesecretref) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeattributes isa Absent || push!(_openapi_output, "volumeAttributes" => _openapi_value.volumeattributes) + _openapi_value.volumehandle isa Absent || push!(_openapi_output, "volumeHandle" => _openapi_value.volumehandle) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LocalObjectReference + name::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LocalObjectReference}, value) = _decode(IoK8sApiCoreV1LocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1LocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LocalObjectReference") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LocalObjectReference(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1LocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, value) = _decode(IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource/properties/volumeAttributes"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CSIVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + nodepublishsecretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeattributes::Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, value) = _decode(IoK8sApiCoreV1CSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CSIVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1CSIVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_nodepublishsecretref = haskey(_openapi_object, "nodePublishSecretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["nodePublishSecretRef"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeattributes = haskey(_openapi_object, "volumeAttributes") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSourceVolumeAttributes,Nothing}, _openapi_object["volumeAttributes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","nodePublishSecretRef","readOnly","volumeAttributes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CSIVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, nodepublishsecretref = _openapi_field_nodepublishsecretref, readonly = _openapi_field_readonly, volumeattributes = _openapi_field_volumeattributes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.nodepublishsecretref isa Absent || (_openapi_output["nodePublishSecretRef"] = _encode(_openapi_value.nodepublishsecretref)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeattributes isa Absent || (_openapi_output["volumeAttributes"] = _encode(_openapi_value.volumeattributes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.nodepublishsecretref isa Absent || push!(_openapi_output, "nodePublishSecretRef" => _openapi_value.nodepublishsecretref) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeattributes isa Absent || push!(_openapi_output, "volumeAttributes" => _openapi_value.volumeattributes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Capabilities + add::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + drop::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Capabilities}, value) = _decode(IoK8sApiCoreV1Capabilities, value, true) +function _decode(::Type{IoK8sApiCoreV1Capabilities}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_raw, "decoding IoK8sApiCoreV1Capabilities"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Capabilities") + _openapi_field_add = haskey(_openapi_object, "add") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["add"], _openapi_validate) : ABSENT + _openapi_field_drop = haskey(_openapi_object, "drop") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["drop"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("add","drop") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Capabilities(; add = _openapi_field_add, drop = _openapi_field_drop, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.add isa Absent || (_openapi_output["add"] = _encode(_openapi_value.add)) + _openapi_value.drop isa Absent || (_openapi_output["drop"] = _encode(_openapi_value.drop)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Capabilities"), _openapi_output, "encoding IoK8sApiCoreV1Capabilities"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Capabilities) + _openapi_output = Pair{String,Any}[] + _openapi_value.add isa Absent || push!(_openapi_output, "add" => _openapi_value.add) + _openapi_value.drop isa Absent || push!(_openapi_output, "drop" => _openapi_value.drop) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CephFSPersistentVolumeSource + monitors::Union{Nothing,Vector{String}} + path::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretfile::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CephFSPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CephFSPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CephFSPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CephFSPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CephFSPersistentVolumeSource") + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1CephFSPersistentVolumeSource"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretfile = haskey(_openapi_object, "secretFile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretFile"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("monitors","path","readOnly","secretFile","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CephFSPersistentVolumeSource(; monitors = _openapi_field_monitors, path = _openapi_field_path, readonly = _openapi_field_readonly, secretfile = _openapi_field_secretfile, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CephFSPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretfile isa Absent || (_openapi_output["secretFile"] = _encode(_openapi_value.secretfile)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CephFSPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CephFSPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretfile isa Absent || push!(_openapi_output, "secretFile" => _openapi_value.secretfile) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CephFSVolumeSource + monitors::Union{Nothing,Vector{String}} + path::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretfile::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, value) = _decode(IoK8sApiCoreV1CephFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CephFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CephFSVolumeSource") + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1CephFSVolumeSource"), _openapi_validate) + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretfile = haskey(_openapi_object, "secretFile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretFile"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("monitors","path","readOnly","secretFile","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CephFSVolumeSource(; monitors = _openapi_field_monitors, path = _openapi_field_path, readonly = _openapi_field_readonly, secretfile = _openapi_field_secretfile, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretfile isa Absent || (_openapi_output["secretFile"] = _encode(_openapi_value.secretfile)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CephFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CephFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CephFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretfile isa Absent || push!(_openapi_output, "secretFile" => _openapi_value.secretfile) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CinderPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CinderPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1CinderPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CinderPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CinderPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CinderPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1CinderPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CinderPersistentVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CinderPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CinderPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CinderPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1CinderVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, value) = _decode(IoK8sApiCoreV1CinderVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1CinderVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1CinderVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1CinderVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1CinderVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.CinderVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1CinderVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1CinderVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ClientIPConfig + timeoutseconds::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ClientIPConfig}, value) = _decode(IoK8sApiCoreV1ClientIPConfig, value, true) +function _decode(::Type{IoK8sApiCoreV1ClientIPConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClientIPConfig"), _openapi_raw, "decoding IoK8sApiCoreV1ClientIPConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ClientIPConfig") + _openapi_field_timeoutseconds = haskey(_openapi_object, "timeoutSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["timeoutSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("timeoutSeconds",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ClientIPConfig(; timeoutseconds = _openapi_field_timeoutseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ClientIPConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.timeoutseconds isa Absent || (_openapi_output["timeoutSeconds"] = _encode(_openapi_value.timeoutseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClientIPConfig"), _openapi_output, "encoding IoK8sApiCoreV1ClientIPConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ClientIPConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.timeoutseconds isa Absent || push!(_openapi_output, "timeoutSeconds" => _openapi_value.timeoutseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ClusterTrustBundleProjection + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + signername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, value) = _decode(IoK8sApiCoreV1ClusterTrustBundleProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ClusterTrustBundleProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ClusterTrustBundleProjection") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ClusterTrustBundleProjection"), _openapi_validate) + _openapi_field_signername = haskey(_openapi_object, "signerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["signerName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","name","optional","path","signerName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ClusterTrustBundleProjection(; labelselector = _openapi_field_labelselector, name = _openapi_field_name, optional = _openapi_field_optional, path = _openapi_field_path, signername = _openapi_field_signername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ClusterTrustBundleProjection"), _openapi_output, "encoding IoK8sApiCoreV1ClusterTrustBundleProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ClusterTrustBundleProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ComponentCondition + error::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ComponentCondition}, value) = _decode(IoK8sApiCoreV1ComponentCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1ComponentCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentCondition"), _openapi_raw, "decoding IoK8sApiCoreV1ComponentCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ComponentCondition") + _openapi_field_error = haskey(_openapi_object, "error") ? _decode(Union{Absent,Nothing,String}, _openapi_object["error"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1ComponentCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1ComponentCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("error","message","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ComponentCondition(; error = _openapi_field_error, message = _openapi_field_message, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ComponentCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.error isa Absent || (_openapi_output["error"] = _encode(_openapi_value.error)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentCondition"), _openapi_output, "encoding IoK8sApiCoreV1ComponentCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ComponentCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.error isa Absent || push!(_openapi_output, "error" => _openapi_value.error) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ComponentStatus + apiversion::Union{Absent,Nothing,String} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ComponentCondition}}} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ComponentStatus}, value) = _decode(IoK8sApiCoreV1ComponentStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ComponentStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ComponentStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ComponentStatus") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ComponentCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","conditions","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ComponentStatus(; apiversion = _openapi_field_apiversion, conditions = _openapi_field_conditions, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ComponentStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatus"), _openapi_output, "encoding IoK8sApiCoreV1ComponentStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ComponentStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1ListMeta + continue_::Union{Absent,Nothing,String} = ABSENT + remainingitemcount::Union{Absent,Int64,Nothing} = ABSENT + resourceversion::Union{Absent,Nothing,String} = ABSENT + selflink::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, value) = _decode(IoK8sApimachineryPkgApisMetaV1ListMeta, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1ListMeta}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1ListMeta") + _openapi_field_continue_ = haskey(_openapi_object, "continue") ? _decode(Union{Absent,Nothing,String}, _openapi_object["continue"], _openapi_validate) : ABSENT + _openapi_field_remainingitemcount = haskey(_openapi_object, "remainingItemCount") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["remainingItemCount"], _openapi_validate) : ABSENT + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_selflink = haskey(_openapi_object, "selfLink") ? _decode(Union{Absent,Nothing,String}, _openapi_object["selfLink"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("continue","remainingItemCount","resourceVersion","selfLink") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1ListMeta(; continue_ = _openapi_field_continue_, remainingitemcount = _openapi_field_remainingitemcount, resourceversion = _openapi_field_resourceversion, selflink = _openapi_field_selflink, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.continue_ isa Absent || (_openapi_output["continue"] = _encode(_openapi_value.continue_)) + _openapi_value.remainingitemcount isa Absent || (_openapi_output["remainingItemCount"] = _encode(_openapi_value.remainingitemcount)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.selflink isa Absent || (_openapi_output["selfLink"] = _encode(_openapi_value.selflink)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1ListMeta"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1ListMeta) + _openapi_output = Pair{String,Any}[] + _openapi_value.continue_ isa Absent || push!(_openapi_output, "continue" => _openapi_value.continue_) + _openapi_value.remainingitemcount isa Absent || push!(_openapi_output, "remainingItemCount" => _openapi_value.remainingitemcount) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.selflink isa Absent || push!(_openapi_output, "selfLink" => _openapi_value.selflink) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ComponentStatusList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1ComponentStatus}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ComponentStatusList}, value) = _decode(IoK8sApiCoreV1ComponentStatusList, value, true) +function _decode(::Type{IoK8sApiCoreV1ComponentStatusList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatusList"), _openapi_raw, "decoding IoK8sApiCoreV1ComponentStatusList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ComponentStatusList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ComponentStatus}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ComponentStatusList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ComponentStatusList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ComponentStatusList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ComponentStatusList"), _openapi_output, "encoding IoK8sApiCoreV1ComponentStatusList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ComponentStatusList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapBinaryData + additional_properties::Dict{String,Vector{UInt8}} = Dict{String,Vector{UInt8}}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapBinaryData}, value) = _decode(IoK8sApiCoreV1ConfigMapBinaryData, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapBinaryData}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap/properties/binaryData"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapBinaryData"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapBinaryData") + _openapi_additional_properties = Dict{String,Vector{UInt8}}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Vector{UInt8}, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapBinaryData(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapBinaryData) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap/properties/binaryData"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapBinaryData"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapBinaryData) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapData + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapData}, value) = _decode(IoK8sApiCoreV1ConfigMapData, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapData}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap/properties/data"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapData"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapData") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapData(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapData) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap/properties/data"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapData"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapData) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMap + apiversion::Union{Absent,Nothing,String} = ABSENT + binarydata::Union{Absent,IoK8sApiCoreV1ConfigMapBinaryData,Nothing} = ABSENT + data::Union{Absent,IoK8sApiCoreV1ConfigMapData,Nothing} = ABSENT + immutable::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMap}, value) = _decode(IoK8sApiCoreV1ConfigMap, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMap}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMap"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMap") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_binarydata = haskey(_openapi_object, "binaryData") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapBinaryData,Nothing}, _openapi_object["binaryData"], _openapi_validate) : ABSENT + _openapi_field_data = haskey(_openapi_object, "data") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapData,Nothing}, _openapi_object["data"], _openapi_validate) : ABSENT + _openapi_field_immutable = haskey(_openapi_object, "immutable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["immutable"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","binaryData","data","immutable","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMap(; apiversion = _openapi_field_apiversion, binarydata = _openapi_field_binarydata, data = _openapi_field_data, immutable = _openapi_field_immutable, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMap) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.binarydata isa Absent || (_openapi_output["binaryData"] = _encode(_openapi_value.binarydata)) + _openapi_value.data isa Absent || (_openapi_output["data"] = _encode(_openapi_value.data)) + _openapi_value.immutable isa Absent || (_openapi_output["immutable"] = _encode(_openapi_value.immutable)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMap"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMap"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMap) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.binarydata isa Absent || push!(_openapi_output, "binaryData" => _openapi_value.binarydata) + _openapi_value.data isa Absent || push!(_openapi_output, "data" => _openapi_value.data) + _openapi_value.immutable isa Absent || push!(_openapi_output, "immutable" => _openapi_value.immutable) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, value) = _decode(IoK8sApiCoreV1ConfigMapEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, value) = _decode(IoK8sApiCoreV1ConfigMapKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1ConfigMapKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1ConfigMap}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapList}, value) = _decode(IoK8sApiCoreV1ConfigMapList, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapList"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ConfigMap}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ConfigMapList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapList"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapNodeConfigSource + kubeletconfigkey::String + name::String + namespace::String + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapNodeConfigSource}, value) = _decode(IoK8sApiCoreV1ConfigMapNodeConfigSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapNodeConfigSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapNodeConfigSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapNodeConfigSource") + _openapi_field_kubeletconfigkey = _decode(String, _required(_openapi_object, "kubeletConfigKey", "IoK8sApiCoreV1ConfigMapNodeConfigSource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ConfigMapNodeConfigSource"), _openapi_validate) + _openapi_field_namespace = _decode(String, _required(_openapi_object, "namespace", "IoK8sApiCoreV1ConfigMapNodeConfigSource"), _openapi_validate) + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("kubeletConfigKey","name","namespace","resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapNodeConfigSource(; kubeletconfigkey = _openapi_field_kubeletconfigkey, name = _openapi_field_name, namespace = _openapi_field_namespace, resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapNodeConfigSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.kubeletconfigkey isa Absent || (_openapi_output["kubeletConfigKey"] = _encode(_openapi_value.kubeletconfigkey)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapNodeConfigSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapNodeConfigSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapNodeConfigSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.kubeletconfigkey isa Absent || push!(_openapi_output, "kubeletConfigKey" => _openapi_value.kubeletconfigkey) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1KeyToPath + key::String + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1KeyToPath}, value) = _decode(IoK8sApiCoreV1KeyToPath, value, true) +function _decode(::Type{IoK8sApiCoreV1KeyToPath}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_raw, "decoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1KeyToPath") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1KeyToPath"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","mode","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1KeyToPath(; key = _openapi_field_key, mode = _openapi_field_mode, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.KeyToPath"), _openapi_output, "encoding IoK8sApiCoreV1KeyToPath"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1KeyToPath) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, value) = _decode(IoK8sApiCoreV1ConfigMapProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapProjection"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ConfigMapVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, value) = _decode(IoK8sApiCoreV1ConfigMapVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ConfigMapVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ConfigMapVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ConfigMapVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ConfigMapVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ConfigMapVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ConfigMapVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ObjectFieldSelector + apiversion::Union{Absent,Nothing,String} = ABSENT + fieldpath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, value) = _decode(IoK8sApiCoreV1ObjectFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ObjectFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ObjectFieldSelector") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_fieldpath = _decode(String, _required(_openapi_object, "fieldPath", "IoK8sApiCoreV1ObjectFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","fieldPath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ObjectFieldSelector(; apiversion = _openapi_field_apiversion, fieldpath = _openapi_field_fieldpath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.fieldpath isa Absent || (_openapi_output["fieldPath"] = _encode(_openapi_value.fieldpath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ObjectFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ObjectFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ObjectFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.fieldpath isa Absent || push!(_openapi_output, "fieldPath" => _openapi_value.fieldpath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FileKeySelector + key::String + optional::Union{Absent,Bool,Nothing} = ABSENT + path::String + volumename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FileKeySelector}, value) = _decode(IoK8sApiCoreV1FileKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1FileKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FileKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_field_volumename = _decode(String, _required(_openapi_object, "volumeName", "IoK8sApiCoreV1FileKeySelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","optional","path","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FileKeySelector(; key = _openapi_field_key, optional = _openapi_field_optional, path = _openapi_field_path, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FileKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1FileKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FileKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgApiResourceQuantity + value::Union{Float64,String} +end +_decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value) = _decode(IoK8sApimachineryPkgApiResourceQuantity, value, true) +function _decode(::Type{IoK8sApimachineryPkgApiResourceQuantity}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), value, "decoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(Float64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgApiResourceQuantity")) + return IoK8sApimachineryPkgApiResourceQuantity(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgApiResourceQuantity) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.api.resource.Quantity"), output, "encoding IoK8sApimachineryPkgApiResourceQuantity"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceFieldSelector + containername::Union{Absent,Nothing,String} = ABSENT + divisor::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + resource::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, value) = _decode(IoK8sApiCoreV1ResourceFieldSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceFieldSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceFieldSelector") + _openapi_field_containername = haskey(_openapi_object, "containerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerName"], _openapi_validate) : ABSENT + _openapi_field_divisor = haskey(_openapi_object, "divisor") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["divisor"], _openapi_validate) : ABSENT + _openapi_field_resource = _decode(String, _required(_openapi_object, "resource", "IoK8sApiCoreV1ResourceFieldSelector"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerName","divisor","resource") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceFieldSelector(; containername = _openapi_field_containername, divisor = _openapi_field_divisor, resource = _openapi_field_resource, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containername isa Absent || (_openapi_output["containerName"] = _encode(_openapi_value.containername)) + _openapi_value.divisor isa Absent || (_openapi_output["divisor"] = _encode(_openapi_value.divisor)) + _openapi_value.resource isa Absent || (_openapi_output["resource"] = _encode(_openapi_value.resource)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceFieldSelector"), _openapi_output, "encoding IoK8sApiCoreV1ResourceFieldSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceFieldSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.containername isa Absent || push!(_openapi_output, "containerName" => _openapi_value.containername) + _openapi_value.divisor isa Absent || push!(_openapi_output, "divisor" => _openapi_value.divisor) + _openapi_value.resource isa Absent || push!(_openapi_output, "resource" => _openapi_value.resource) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretKeySelector + key::String + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretKeySelector}, value) = _decode(IoK8sApiCoreV1SecretKeySelector, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretKeySelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_raw, "decoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretKeySelector") + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1SecretKeySelector"), _openapi_validate) + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("key","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretKeySelector(; key = _openapi_field_key, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretKeySelector"), _openapi_output, "encoding IoK8sApiCoreV1SecretKeySelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretKeySelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVarSource + configmapkeyref::Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing} = ABSENT + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + filekeyref::Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing} = ABSENT + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + secretkeyref::Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVarSource}, value) = _decode(IoK8sApiCoreV1EnvVarSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVarSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVarSource") + _openapi_field_configmapkeyref = haskey(_openapi_object, "configMapKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapKeySelector,Nothing}, _openapi_object["configMapKeyRef"], _openapi_validate) : ABSENT + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_filekeyref = haskey(_openapi_object, "fileKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1FileKeySelector,Nothing}, _openapi_object["fileKeyRef"], _openapi_validate) : ABSENT + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_field_secretkeyref = haskey(_openapi_object, "secretKeyRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretKeySelector,Nothing}, _openapi_object["secretKeyRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapKeyRef","fieldRef","fileKeyRef","resourceFieldRef","secretKeyRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVarSource(; configmapkeyref = _openapi_field_configmapkeyref, fieldref = _openapi_field_fieldref, filekeyref = _openapi_field_filekeyref, resourcefieldref = _openapi_field_resourcefieldref, secretkeyref = _openapi_field_secretkeyref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapkeyref isa Absent || (_openapi_output["configMapKeyRef"] = _encode(_openapi_value.configmapkeyref)) + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.filekeyref isa Absent || (_openapi_output["fileKeyRef"] = _encode(_openapi_value.filekeyref)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + _openapi_value.secretkeyref isa Absent || (_openapi_output["secretKeyRef"] = _encode(_openapi_value.secretkeyref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVarSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvVarSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVarSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapkeyref isa Absent || push!(_openapi_output, "configMapKeyRef" => _openapi_value.configmapkeyref) + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.filekeyref isa Absent || push!(_openapi_output, "fileKeyRef" => _openapi_value.filekeyref) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + _openapi_value.secretkeyref isa Absent || push!(_openapi_output, "secretKeyRef" => _openapi_value.secretkeyref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvVar + name::String + value::Union{Absent,Nothing,String} = ABSENT + valuefrom::Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvVar}, value) = _decode(IoK8sApiCoreV1EnvVar, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvVar}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_raw, "decoding IoK8sApiCoreV1EnvVar"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvVar") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EnvVar"), _openapi_validate) + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_field_valuefrom = haskey(_openapi_object, "valueFrom") ? _decode(Union{Absent,IoK8sApiCoreV1EnvVarSource,Nothing}, _openapi_object["valueFrom"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value","valueFrom") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvVar(; name = _openapi_field_name, value = _openapi_field_value, valuefrom = _openapi_field_valuefrom, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + _openapi_value.valuefrom isa Absent || (_openapi_output["valueFrom"] = _encode(_openapi_value.valuefrom)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvVar"), _openapi_output, "encoding IoK8sApiCoreV1EnvVar"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvVar) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + _openapi_value.valuefrom isa Absent || push!(_openapi_output, "valueFrom" => _openapi_value.valuefrom) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretEnvSource + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretEnvSource}, value) = _decode(IoK8sApiCoreV1SecretEnvSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretEnvSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretEnvSource") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretEnvSource(; name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretEnvSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretEnvSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretEnvSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EnvFromSource + configmapref::Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing} = ABSENT + prefix::Union{Absent,Nothing,String} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EnvFromSource}, value) = _decode(IoK8sApiCoreV1EnvFromSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EnvFromSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_raw, "decoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EnvFromSource") + _openapi_field_configmapref = haskey(_openapi_object, "configMapRef") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapEnvSource,Nothing}, _openapi_object["configMapRef"], _openapi_validate) : ABSENT + _openapi_field_prefix = haskey(_openapi_object, "prefix") ? _decode(Union{Absent,Nothing,String}, _openapi_object["prefix"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretEnvSource,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMapRef","prefix","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EnvFromSource(; configmapref = _openapi_field_configmapref, prefix = _openapi_field_prefix, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmapref isa Absent || (_openapi_output["configMapRef"] = _encode(_openapi_value.configmapref)) + _openapi_value.prefix isa Absent || (_openapi_output["prefix"] = _encode(_openapi_value.prefix)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EnvFromSource"), _openapi_output, "encoding IoK8sApiCoreV1EnvFromSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EnvFromSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmapref isa Absent || push!(_openapi_output, "configMapRef" => _openapi_value.configmapref) + _openapi_value.prefix isa Absent || push!(_openapi_output, "prefix" => _openapi_value.prefix) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ExecAction + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ExecAction}, value) = _decode(IoK8sApiCoreV1ExecAction, value, true) +function _decode(::Type{IoK8sApiCoreV1ExecAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_raw, "decoding IoK8sApiCoreV1ExecAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ExecAction") + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("command",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ExecAction(; command = _openapi_field_command, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ExecAction"), _openapi_output, "encoding IoK8sApiCoreV1ExecAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ExecAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPHeader + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPHeader}, value) = _decode(IoK8sApiCoreV1HTTPHeader, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPHeader}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPHeader") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1HTTPHeader"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPHeader(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPHeader"), _openapi_output, "encoding IoK8sApiCoreV1HTTPHeader"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPHeader) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +struct IoK8sApimachineryPkgUtilIntstrIntOrString + value::Union{Int64,String} +end +_decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value) = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, value, true) +function _decode(::Type{IoK8sApimachineryPkgUtilIntstrIntOrString}, value, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), value, "decoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) + matches = Any[] + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/0"), value; direction = :neutral) + try + push!(matches, _decode(Int64, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + if !_openapi_validate || _schema_valid(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString/oneOf/1"), value; direction = :neutral) + try + push!(matches, _decode(String, value, _openapi_validate)) + catch error + error isa DecodeError || rethrow() + end + end + length(matches) == 1 || throw(DecodeError("oneOf value did not select exactly one variant of IoK8sApimachineryPkgUtilIntstrIntOrString")) + return IoK8sApimachineryPkgUtilIntstrIntOrString(first(matches)) +end +function _encode(value::IoK8sApimachineryPkgUtilIntstrIntOrString) + output = _encode(value.value) + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.util.intstr.IntOrString"), output, "encoding IoK8sApimachineryPkgUtilIntstrIntOrString"; direction = :neutral) +end + +Base.@kwdef struct IoK8sApiCoreV1HTTPGetAction + host::Union{Absent,Nothing,String} = ABSENT + httpheaders::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}} = ABSENT + path::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + scheme::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HTTPGetAction}, value) = _decode(IoK8sApiCoreV1HTTPGetAction, value, true) +function _decode(::Type{IoK8sApiCoreV1HTTPGetAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_raw, "decoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HTTPGetAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_httpheaders = haskey(_openapi_object, "httpHeaders") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HTTPHeader}}}, _openapi_object["httpHeaders"], _openapi_validate) : ABSENT + _openapi_field_path = haskey(_openapi_object, "path") ? _decode(Union{Absent,Nothing,String}, _openapi_object["path"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1HTTPGetAction"), _openapi_validate) + _openapi_field_scheme = haskey(_openapi_object, "scheme") ? _decode(Union{Absent,Nothing,String}, _openapi_object["scheme"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","httpHeaders","path","port","scheme") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HTTPGetAction(; host = _openapi_field_host, httpheaders = _openapi_field_httpheaders, path = _openapi_field_path, port = _openapi_field_port, scheme = _openapi_field_scheme, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.httpheaders isa Absent || (_openapi_output["httpHeaders"] = _encode(_openapi_value.httpheaders)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.scheme isa Absent || (_openapi_output["scheme"] = _encode(_openapi_value.scheme)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HTTPGetAction"), _openapi_output, "encoding IoK8sApiCoreV1HTTPGetAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HTTPGetAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.httpheaders isa Absent || push!(_openapi_output, "httpHeaders" => _openapi_value.httpheaders) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.scheme isa Absent || push!(_openapi_output, "scheme" => _openapi_value.scheme) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SleepAction + seconds::Int64 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SleepAction}, value) = _decode(IoK8sApiCoreV1SleepAction, value, true) +function _decode(::Type{IoK8sApiCoreV1SleepAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_raw, "decoding IoK8sApiCoreV1SleepAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SleepAction") + _openapi_field_seconds = _decode(Int64, _required(_openapi_object, "seconds", "IoK8sApiCoreV1SleepAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("seconds",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SleepAction(; seconds = _openapi_field_seconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.seconds isa Absent || (_openapi_output["seconds"] = _encode(_openapi_value.seconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SleepAction"), _openapi_output, "encoding IoK8sApiCoreV1SleepAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SleepAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.seconds isa Absent || push!(_openapi_output, "seconds" => _openapi_value.seconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TCPSocketAction + host::Union{Absent,Nothing,String} = ABSENT + port::IoK8sApimachineryPkgUtilIntstrIntOrString + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TCPSocketAction}, value) = _decode(IoK8sApiCoreV1TCPSocketAction, value, true) +function _decode(::Type{IoK8sApiCoreV1TCPSocketAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_raw, "decoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TCPSocketAction") + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(IoK8sApimachineryPkgUtilIntstrIntOrString, _required(_openapi_object, "port", "IoK8sApiCoreV1TCPSocketAction"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("host","port") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TCPSocketAction(; host = _openapi_field_host, port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TCPSocketAction"), _openapi_output, "encoding IoK8sApiCoreV1TCPSocketAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TCPSocketAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LifecycleHandler + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + sleep::Union{Absent,IoK8sApiCoreV1SleepAction,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LifecycleHandler}, value) = _decode(IoK8sApiCoreV1LifecycleHandler, value, true) +function _decode(::Type{IoK8sApiCoreV1LifecycleHandler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_raw, "decoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LifecycleHandler") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_sleep = haskey(_openapi_object, "sleep") ? _decode(Union{Absent,IoK8sApiCoreV1SleepAction,Nothing}, _openapi_object["sleep"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","httpGet","sleep","tcpSocket") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LifecycleHandler(; exec = _openapi_field_exec, httpget = _openapi_field_httpget, sleep = _openapi_field_sleep, tcpsocket = _openapi_field_tcpsocket, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.sleep isa Absent || (_openapi_output["sleep"] = _encode(_openapi_value.sleep)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LifecycleHandler"), _openapi_output, "encoding IoK8sApiCoreV1LifecycleHandler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LifecycleHandler) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.sleep isa Absent || push!(_openapi_output, "sleep" => _openapi_value.sleep) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Lifecycle + poststart::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + prestop::Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing} = ABSENT + stopsignal::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Lifecycle}, value) = _decode(IoK8sApiCoreV1Lifecycle, value, true) +function _decode(::Type{IoK8sApiCoreV1Lifecycle}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_raw, "decoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Lifecycle") + _openapi_field_poststart = haskey(_openapi_object, "postStart") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["postStart"], _openapi_validate) : ABSENT + _openapi_field_prestop = haskey(_openapi_object, "preStop") ? _decode(Union{Absent,IoK8sApiCoreV1LifecycleHandler,Nothing}, _openapi_object["preStop"], _openapi_validate) : ABSENT + _openapi_field_stopsignal = haskey(_openapi_object, "stopSignal") ? _decode(Union{Absent,Nothing,String}, _openapi_object["stopSignal"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("postStart","preStop","stopSignal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Lifecycle(; poststart = _openapi_field_poststart, prestop = _openapi_field_prestop, stopsignal = _openapi_field_stopsignal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.poststart isa Absent || (_openapi_output["postStart"] = _encode(_openapi_value.poststart)) + _openapi_value.prestop isa Absent || (_openapi_output["preStop"] = _encode(_openapi_value.prestop)) + _openapi_value.stopsignal isa Absent || (_openapi_output["stopSignal"] = _encode(_openapi_value.stopsignal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Lifecycle"), _openapi_output, "encoding IoK8sApiCoreV1Lifecycle"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Lifecycle) + _openapi_output = Pair{String,Any}[] + _openapi_value.poststart isa Absent || push!(_openapi_output, "postStart" => _openapi_value.poststart) + _openapi_value.prestop isa Absent || push!(_openapi_output, "preStop" => _openapi_value.prestop) + _openapi_value.stopsignal isa Absent || push!(_openapi_output, "stopSignal" => _openapi_value.stopsignal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GRPCAction + port::Int32 + service::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GRPCAction}, value) = _decode(IoK8sApiCoreV1GRPCAction, value, true) +function _decode(::Type{IoK8sApiCoreV1GRPCAction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_raw, "decoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GRPCAction") + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1GRPCAction"), _openapi_validate) + _openapi_field_service = haskey(_openapi_object, "service") ? _decode(Union{Absent,Nothing,String}, _openapi_object["service"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("port","service") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GRPCAction(; port = _openapi_field_port, service = _openapi_field_service, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.service isa Absent || (_openapi_output["service"] = _encode(_openapi_value.service)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GRPCAction"), _openapi_output, "encoding IoK8sApiCoreV1GRPCAction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GRPCAction) + _openapi_output = Pair{String,Any}[] + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.service isa Absent || push!(_openapi_output, "service" => _openapi_value.service) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Probe + exec::Union{Absent,IoK8sApiCoreV1ExecAction,Nothing} = ABSENT + failurethreshold::Union{Absent,Int32,Nothing} = ABSENT + grpc::Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing} = ABSENT + httpget::Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing} = ABSENT + initialdelayseconds::Union{Absent,Int32,Nothing} = ABSENT + periodseconds::Union{Absent,Int32,Nothing} = ABSENT + successthreshold::Union{Absent,Int32,Nothing} = ABSENT + tcpsocket::Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + timeoutseconds::Union{Absent,Int32,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Probe}, value) = _decode(IoK8sApiCoreV1Probe, value, true) +function _decode(::Type{IoK8sApiCoreV1Probe}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_raw, "decoding IoK8sApiCoreV1Probe"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Probe") + _openapi_field_exec = haskey(_openapi_object, "exec") ? _decode(Union{Absent,IoK8sApiCoreV1ExecAction,Nothing}, _openapi_object["exec"], _openapi_validate) : ABSENT + _openapi_field_failurethreshold = haskey(_openapi_object, "failureThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["failureThreshold"], _openapi_validate) : ABSENT + _openapi_field_grpc = haskey(_openapi_object, "grpc") ? _decode(Union{Absent,IoK8sApiCoreV1GRPCAction,Nothing}, _openapi_object["grpc"], _openapi_validate) : ABSENT + _openapi_field_httpget = haskey(_openapi_object, "httpGet") ? _decode(Union{Absent,IoK8sApiCoreV1HTTPGetAction,Nothing}, _openapi_object["httpGet"], _openapi_validate) : ABSENT + _openapi_field_initialdelayseconds = haskey(_openapi_object, "initialDelaySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["initialDelaySeconds"], _openapi_validate) : ABSENT + _openapi_field_periodseconds = haskey(_openapi_object, "periodSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["periodSeconds"], _openapi_validate) : ABSENT + _openapi_field_successthreshold = haskey(_openapi_object, "successThreshold") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["successThreshold"], _openapi_validate) : ABSENT + _openapi_field_tcpsocket = haskey(_openapi_object, "tcpSocket") ? _decode(Union{Absent,IoK8sApiCoreV1TCPSocketAction,Nothing}, _openapi_object["tcpSocket"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_timeoutseconds = haskey(_openapi_object, "timeoutSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["timeoutSeconds"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("exec","failureThreshold","grpc","httpGet","initialDelaySeconds","periodSeconds","successThreshold","tcpSocket","terminationGracePeriodSeconds","timeoutSeconds") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Probe(; exec = _openapi_field_exec, failurethreshold = _openapi_field_failurethreshold, grpc = _openapi_field_grpc, httpget = _openapi_field_httpget, initialdelayseconds = _openapi_field_initialdelayseconds, periodseconds = _openapi_field_periodseconds, successthreshold = _openapi_field_successthreshold, tcpsocket = _openapi_field_tcpsocket, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, timeoutseconds = _openapi_field_timeoutseconds, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.exec isa Absent || (_openapi_output["exec"] = _encode(_openapi_value.exec)) + _openapi_value.failurethreshold isa Absent || (_openapi_output["failureThreshold"] = _encode(_openapi_value.failurethreshold)) + _openapi_value.grpc isa Absent || (_openapi_output["grpc"] = _encode(_openapi_value.grpc)) + _openapi_value.httpget isa Absent || (_openapi_output["httpGet"] = _encode(_openapi_value.httpget)) + _openapi_value.initialdelayseconds isa Absent || (_openapi_output["initialDelaySeconds"] = _encode(_openapi_value.initialdelayseconds)) + _openapi_value.periodseconds isa Absent || (_openapi_output["periodSeconds"] = _encode(_openapi_value.periodseconds)) + _openapi_value.successthreshold isa Absent || (_openapi_output["successThreshold"] = _encode(_openapi_value.successthreshold)) + _openapi_value.tcpsocket isa Absent || (_openapi_output["tcpSocket"] = _encode(_openapi_value.tcpsocket)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.timeoutseconds isa Absent || (_openapi_output["timeoutSeconds"] = _encode(_openapi_value.timeoutseconds)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Probe"), _openapi_output, "encoding IoK8sApiCoreV1Probe"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Probe) + _openapi_output = Pair{String,Any}[] + _openapi_value.exec isa Absent || push!(_openapi_output, "exec" => _openapi_value.exec) + _openapi_value.failurethreshold isa Absent || push!(_openapi_output, "failureThreshold" => _openapi_value.failurethreshold) + _openapi_value.grpc isa Absent || push!(_openapi_output, "grpc" => _openapi_value.grpc) + _openapi_value.httpget isa Absent || push!(_openapi_output, "httpGet" => _openapi_value.httpget) + _openapi_value.initialdelayseconds isa Absent || push!(_openapi_output, "initialDelaySeconds" => _openapi_value.initialdelayseconds) + _openapi_value.periodseconds isa Absent || push!(_openapi_output, "periodSeconds" => _openapi_value.periodseconds) + _openapi_value.successthreshold isa Absent || push!(_openapi_output, "successThreshold" => _openapi_value.successthreshold) + _openapi_value.tcpsocket isa Absent || push!(_openapi_output, "tcpSocket" => _openapi_value.tcpsocket) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.timeoutseconds isa Absent || push!(_openapi_output, "timeoutSeconds" => _openapi_value.timeoutseconds) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerPort + containerport::Int32 + hostip::Union{Absent,Nothing,String} = ABSENT + hostport::Union{Absent,Int32,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerPort}, value) = _decode(IoK8sApiCoreV1ContainerPort, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerPort") + _openapi_field_containerport = _decode(Int32, _required(_openapi_object, "containerPort", "IoK8sApiCoreV1ContainerPort"), _openapi_validate) + _openapi_field_hostip = haskey(_openapi_object, "hostIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostIP"], _openapi_validate) : ABSENT + _openapi_field_hostport = haskey(_openapi_object, "hostPort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["hostPort"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerPort","hostIP","hostPort","name","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerPort(; containerport = _openapi_field_containerport, hostip = _openapi_field_hostip, hostport = _openapi_field_hostport, name = _openapi_field_name, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerport isa Absent || (_openapi_output["containerPort"] = _encode(_openapi_value.containerport)) + _openapi_value.hostip isa Absent || (_openapi_output["hostIP"] = _encode(_openapi_value.hostip)) + _openapi_value.hostport isa Absent || (_openapi_output["hostPort"] = _encode(_openapi_value.hostport)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerPort"), _openapi_output, "encoding IoK8sApiCoreV1ContainerPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerport isa Absent || push!(_openapi_output, "containerPort" => _openapi_value.containerport) + _openapi_value.hostip isa Absent || push!(_openapi_output, "hostIP" => _openapi_value.hostip) + _openapi_value.hostport isa Absent || push!(_openapi_output, "hostPort" => _openapi_value.hostport) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerResizePolicy + resourcename::String + restartpolicy::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, value) = _decode(IoK8sApiCoreV1ContainerResizePolicy, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerResizePolicy}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerResizePolicy") + _openapi_field_resourcename = _decode(String, _required(_openapi_object, "resourceName", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_field_restartpolicy = _decode(String, _required(_openapi_object, "restartPolicy", "IoK8sApiCoreV1ContainerResizePolicy"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceName","restartPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerResizePolicy(; resourcename = _openapi_field_resourcename, restartpolicy = _openapi_field_restartpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourcename isa Absent || (_openapi_output["resourceName"] = _encode(_openapi_value.resourcename)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerResizePolicy"), _openapi_output, "encoding IoK8sApiCoreV1ContainerResizePolicy"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerResizePolicy) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourcename isa Absent || push!(_openapi_output, "resourceName" => _openapi_value.resourcename) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceClaim + name::String + request::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceClaim}, value) = _decode(IoK8sApiCoreV1ResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ResourceClaim"), _openapi_validate) + _openapi_field_request = haskey(_openapi_object, "request") ? _decode(Union{Absent,Nothing,String}, _openapi_object["request"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","request") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceClaim(; name = _openapi_field_name, request = _openapi_field_request, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.request isa Absent || (_openapi_output["request"] = _encode(_openapi_value.request)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1ResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.request isa Absent || push!(_openapi_output, "request" => _openapi_value.request) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1ResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceRequirements + claims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}} = ABSENT + limits::Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceRequirements}, value) = _decode(IoK8sApiCoreV1ResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceRequirements") + _openapi_field_claims = haskey(_openapi_object, "claims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceClaim}}}, _openapi_object["claims"], _openapi_validate) : ABSENT + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claims","limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceRequirements(; claims = _openapi_field_claims, limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claims isa Absent || (_openapi_output["claims"] = _encode(_openapi_value.claims)) + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1ResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.claims isa Absent || push!(_openapi_output, "claims" => _openapi_value.claims) + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRuleOnExitCodes + operator::String + values::Union{Absent,Union{Nothing,Vector{Int32}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, value) = _decode(IoK8sApiCoreV1ContainerRestartRuleOnExitCodes, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRuleOnExitCodes}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes") + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{Int32}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("operator","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRuleOnExitCodes(; operator = _openapi_field_operator, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRuleOnExitCodes"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRuleOnExitCodes) + _openapi_output = Pair{String,Any}[] + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerRestartRule + action::String + exitcodes::Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, value) = _decode(IoK8sApiCoreV1ContainerRestartRule, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerRestartRule}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerRestartRule") + _openapi_field_action = _decode(String, _required(_openapi_object, "action", "IoK8sApiCoreV1ContainerRestartRule"), _openapi_validate) + _openapi_field_exitcodes = haskey(_openapi_object, "exitCodes") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerRestartRuleOnExitCodes,Nothing}, _openapi_object["exitCodes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","exitCodes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerRestartRule(; action = _openapi_field_action, exitcodes = _openapi_field_exitcodes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.exitcodes isa Absent || (_openapi_output["exitCodes"] = _encode(_openapi_value.exitcodes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerRestartRule"), _openapi_output, "encoding IoK8sApiCoreV1ContainerRestartRule"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerRestartRule) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.exitcodes isa Absent || push!(_openapi_output, "exitCodes" => _openapi_value.exitcodes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SELinuxOptions + level::Union{Absent,Nothing,String} = ABSENT + role::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SELinuxOptions}, value) = _decode(IoK8sApiCoreV1SELinuxOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1SELinuxOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_raw, "decoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SELinuxOptions") + _openapi_field_level = haskey(_openapi_object, "level") ? _decode(Union{Absent,Nothing,String}, _openapi_object["level"], _openapi_validate) : ABSENT + _openapi_field_role = haskey(_openapi_object, "role") ? _decode(Union{Absent,Nothing,String}, _openapi_object["role"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("level","role","type","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SELinuxOptions(; level = _openapi_field_level, role = _openapi_field_role, type_ = _openapi_field_type_, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.level isa Absent || (_openapi_output["level"] = _encode(_openapi_value.level)) + _openapi_value.role isa Absent || (_openapi_output["role"] = _encode(_openapi_value.role)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SELinuxOptions"), _openapi_output, "encoding IoK8sApiCoreV1SELinuxOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SELinuxOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.level isa Absent || push!(_openapi_output, "level" => _openapi_value.level) + _openapi_value.role isa Absent || push!(_openapi_output, "role" => _openapi_value.role) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SeccompProfile + localhostprofile::Union{Absent,Nothing,String} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SeccompProfile}, value) = _decode(IoK8sApiCoreV1SeccompProfile, value, true) +function _decode(::Type{IoK8sApiCoreV1SeccompProfile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_raw, "decoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SeccompProfile") + _openapi_field_localhostprofile = haskey(_openapi_object, "localhostProfile") ? _decode(Union{Absent,Nothing,String}, _openapi_object["localhostProfile"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1SeccompProfile"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("localhostProfile","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SeccompProfile(; localhostprofile = _openapi_field_localhostprofile, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.localhostprofile isa Absent || (_openapi_output["localhostProfile"] = _encode(_openapi_value.localhostprofile)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SeccompProfile"), _openapi_output, "encoding IoK8sApiCoreV1SeccompProfile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SeccompProfile) + _openapi_output = Pair{String,Any}[] + _openapi_value.localhostprofile isa Absent || push!(_openapi_output, "localhostProfile" => _openapi_value.localhostprofile) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WindowsSecurityContextOptions + gmsacredentialspec::Union{Absent,Nothing,String} = ABSENT + gmsacredentialspecname::Union{Absent,Nothing,String} = ABSENT + hostprocess::Union{Absent,Bool,Nothing} = ABSENT + runasusername::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, value) = _decode(IoK8sApiCoreV1WindowsSecurityContextOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1WindowsSecurityContextOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_raw, "decoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WindowsSecurityContextOptions") + _openapi_field_gmsacredentialspec = haskey(_openapi_object, "gmsaCredentialSpec") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpec"], _openapi_validate) : ABSENT + _openapi_field_gmsacredentialspecname = haskey(_openapi_object, "gmsaCredentialSpecName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["gmsaCredentialSpecName"], _openapi_validate) : ABSENT + _openapi_field_hostprocess = haskey(_openapi_object, "hostProcess") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostProcess"], _openapi_validate) : ABSENT + _openapi_field_runasusername = haskey(_openapi_object, "runAsUserName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runAsUserName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("gmsaCredentialSpec","gmsaCredentialSpecName","hostProcess","runAsUserName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WindowsSecurityContextOptions(; gmsacredentialspec = _openapi_field_gmsacredentialspec, gmsacredentialspecname = _openapi_field_gmsacredentialspecname, hostprocess = _openapi_field_hostprocess, runasusername = _openapi_field_runasusername, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.gmsacredentialspec isa Absent || (_openapi_output["gmsaCredentialSpec"] = _encode(_openapi_value.gmsacredentialspec)) + _openapi_value.gmsacredentialspecname isa Absent || (_openapi_output["gmsaCredentialSpecName"] = _encode(_openapi_value.gmsacredentialspecname)) + _openapi_value.hostprocess isa Absent || (_openapi_output["hostProcess"] = _encode(_openapi_value.hostprocess)) + _openapi_value.runasusername isa Absent || (_openapi_output["runAsUserName"] = _encode(_openapi_value.runasusername)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WindowsSecurityContextOptions"), _openapi_output, "encoding IoK8sApiCoreV1WindowsSecurityContextOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WindowsSecurityContextOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.gmsacredentialspec isa Absent || push!(_openapi_output, "gmsaCredentialSpec" => _openapi_value.gmsacredentialspec) + _openapi_value.gmsacredentialspecname isa Absent || push!(_openapi_output, "gmsaCredentialSpecName" => _openapi_value.gmsacredentialspecname) + _openapi_value.hostprocess isa Absent || push!(_openapi_output, "hostProcess" => _openapi_value.hostprocess) + _openapi_value.runasusername isa Absent || push!(_openapi_output, "runAsUserName" => _openapi_value.runasusername) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecurityContext + allowprivilegeescalation::Union{Absent,Bool,Nothing} = ABSENT + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + capabilities::Union{Absent,IoK8sApiCoreV1Capabilities,Nothing} = ABSENT + privileged::Union{Absent,Bool,Nothing} = ABSENT + procmount::Union{Absent,Nothing,String} = ABSENT + readonlyrootfilesystem::Union{Absent,Bool,Nothing} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecurityContext}, value) = _decode(IoK8sApiCoreV1SecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1SecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecurityContext") + _openapi_field_allowprivilegeescalation = haskey(_openapi_object, "allowPrivilegeEscalation") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["allowPrivilegeEscalation"], _openapi_validate) : ABSENT + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_capabilities = haskey(_openapi_object, "capabilities") ? _decode(Union{Absent,IoK8sApiCoreV1Capabilities,Nothing}, _openapi_object["capabilities"], _openapi_validate) : ABSENT + _openapi_field_privileged = haskey(_openapi_object, "privileged") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["privileged"], _openapi_validate) : ABSENT + _openapi_field_procmount = haskey(_openapi_object, "procMount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["procMount"], _openapi_validate) : ABSENT + _openapi_field_readonlyrootfilesystem = haskey(_openapi_object, "readOnlyRootFilesystem") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnlyRootFilesystem"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allowPrivilegeEscalation","appArmorProfile","capabilities","privileged","procMount","readOnlyRootFilesystem","runAsGroup","runAsNonRoot","runAsUser","seLinuxOptions","seccompProfile","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecurityContext(; allowprivilegeescalation = _openapi_field_allowprivilegeescalation, apparmorprofile = _openapi_field_apparmorprofile, capabilities = _openapi_field_capabilities, privileged = _openapi_field_privileged, procmount = _openapi_field_procmount, readonlyrootfilesystem = _openapi_field_readonlyrootfilesystem, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allowprivilegeescalation isa Absent || (_openapi_output["allowPrivilegeEscalation"] = _encode(_openapi_value.allowprivilegeescalation)) + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.capabilities isa Absent || (_openapi_output["capabilities"] = _encode(_openapi_value.capabilities)) + _openapi_value.privileged isa Absent || (_openapi_output["privileged"] = _encode(_openapi_value.privileged)) + _openapi_value.procmount isa Absent || (_openapi_output["procMount"] = _encode(_openapi_value.procmount)) + _openapi_value.readonlyrootfilesystem isa Absent || (_openapi_output["readOnlyRootFilesystem"] = _encode(_openapi_value.readonlyrootfilesystem)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1SecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.allowprivilegeescalation isa Absent || push!(_openapi_output, "allowPrivilegeEscalation" => _openapi_value.allowprivilegeescalation) + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.capabilities isa Absent || push!(_openapi_output, "capabilities" => _openapi_value.capabilities) + _openapi_value.privileged isa Absent || push!(_openapi_output, "privileged" => _openapi_value.privileged) + _openapi_value.procmount isa Absent || push!(_openapi_output, "procMount" => _openapi_value.procmount) + _openapi_value.readonlyrootfilesystem isa Absent || push!(_openapi_output, "readOnlyRootFilesystem" => _openapi_value.readonlyrootfilesystem) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeDevice + devicepath::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeDevice}, value) = _decode(IoK8sApiCoreV1VolumeDevice, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeDevice}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeDevice") + _openapi_field_devicepath = _decode(String, _required(_openapi_object, "devicePath", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeDevice"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("devicePath","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeDevice(; devicepath = _openapi_field_devicepath, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.devicepath isa Absent || (_openapi_output["devicePath"] = _encode(_openapi_value.devicepath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeDevice"), _openapi_output, "encoding IoK8sApiCoreV1VolumeDevice"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeDevice) + _openapi_output = Pair{String,Any}[] + _openapi_value.devicepath isa Absent || push!(_openapi_output, "devicePath" => _openapi_value.devicepath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeMount + mountpath::String + mountpropagation::Union{Absent,Nothing,String} = ABSENT + name::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + recursivereadonly::Union{Absent,Nothing,String} = ABSENT + subpath::Union{Absent,Nothing,String} = ABSENT + subpathexpr::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeMount}, value) = _decode(IoK8sApiCoreV1VolumeMount, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeMount}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeMount") + _openapi_field_mountpath = _decode(String, _required(_openapi_object, "mountPath", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_mountpropagation = haskey(_openapi_object, "mountPropagation") ? _decode(Union{Absent,Nothing,String}, _openapi_object["mountPropagation"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeMount"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_recursivereadonly = haskey(_openapi_object, "recursiveReadOnly") ? _decode(Union{Absent,Nothing,String}, _openapi_object["recursiveReadOnly"], _openapi_validate) : ABSENT + _openapi_field_subpath = haskey(_openapi_object, "subPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPath"], _openapi_validate) : ABSENT + _openapi_field_subpathexpr = haskey(_openapi_object, "subPathExpr") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subPathExpr"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("mountPath","mountPropagation","name","readOnly","recursiveReadOnly","subPath","subPathExpr") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeMount(; mountpath = _openapi_field_mountpath, mountpropagation = _openapi_field_mountpropagation, name = _openapi_field_name, readonly = _openapi_field_readonly, recursivereadonly = _openapi_field_recursivereadonly, subpath = _openapi_field_subpath, subpathexpr = _openapi_field_subpathexpr, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.mountpath isa Absent || (_openapi_output["mountPath"] = _encode(_openapi_value.mountpath)) + _openapi_value.mountpropagation isa Absent || (_openapi_output["mountPropagation"] = _encode(_openapi_value.mountpropagation)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.recursivereadonly isa Absent || (_openapi_output["recursiveReadOnly"] = _encode(_openapi_value.recursivereadonly)) + _openapi_value.subpath isa Absent || (_openapi_output["subPath"] = _encode(_openapi_value.subpath)) + _openapi_value.subpathexpr isa Absent || (_openapi_output["subPathExpr"] = _encode(_openapi_value.subpathexpr)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMount"), _openapi_output, "encoding IoK8sApiCoreV1VolumeMount"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeMount) + _openapi_output = Pair{String,Any}[] + _openapi_value.mountpath isa Absent || push!(_openapi_output, "mountPath" => _openapi_value.mountpath) + _openapi_value.mountpropagation isa Absent || push!(_openapi_output, "mountPropagation" => _openapi_value.mountpropagation) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.recursivereadonly isa Absent || push!(_openapi_output, "recursiveReadOnly" => _openapi_value.recursivereadonly) + _openapi_value.subpath isa Absent || push!(_openapi_output, "subPath" => _openapi_value.subpath) + _openapi_value.subpathexpr isa Absent || push!(_openapi_output, "subPathExpr" => _openapi_value.subpathexpr) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Container + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Container}, value) = _decode(IoK8sApiCoreV1Container, value, true) +function _decode(::Type{IoK8sApiCoreV1Container}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_raw, "decoding IoK8sApiCoreV1Container"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Container") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Container"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Container(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Container"), _openapi_output, "encoding IoK8sApiCoreV1Container"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Container) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerExtendedResourceRequest + containername::String + requestname::String + resourcename::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerExtendedResourceRequest}, value) = _decode(IoK8sApiCoreV1ContainerExtendedResourceRequest, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerExtendedResourceRequest}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerExtendedResourceRequest"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerExtendedResourceRequest") + _openapi_field_containername = _decode(String, _required(_openapi_object, "containerName", "IoK8sApiCoreV1ContainerExtendedResourceRequest"), _openapi_validate) + _openapi_field_requestname = _decode(String, _required(_openapi_object, "requestName", "IoK8sApiCoreV1ContainerExtendedResourceRequest"), _openapi_validate) + _openapi_field_resourcename = _decode(String, _required(_openapi_object, "resourceName", "IoK8sApiCoreV1ContainerExtendedResourceRequest"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerName","requestName","resourceName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerExtendedResourceRequest(; containername = _openapi_field_containername, requestname = _openapi_field_requestname, resourcename = _openapi_field_resourcename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerExtendedResourceRequest) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containername isa Absent || (_openapi_output["containerName"] = _encode(_openapi_value.containername)) + _openapi_value.requestname isa Absent || (_openapi_output["requestName"] = _encode(_openapi_value.requestname)) + _openapi_value.resourcename isa Absent || (_openapi_output["resourceName"] = _encode(_openapi_value.resourcename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerExtendedResourceRequest"), _openapi_output, "encoding IoK8sApiCoreV1ContainerExtendedResourceRequest"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerExtendedResourceRequest) + _openapi_output = Pair{String,Any}[] + _openapi_value.containername isa Absent || push!(_openapi_output, "containerName" => _openapi_value.containername) + _openapi_value.requestname isa Absent || push!(_openapi_output, "requestName" => _openapi_value.requestname) + _openapi_value.resourcename isa Absent || push!(_openapi_output, "resourceName" => _openapi_value.resourcename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerImage + names::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + sizebytes::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerImage}, value) = _decode(IoK8sApiCoreV1ContainerImage, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerImage}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerImage"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerImage"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerImage") + _openapi_field_names = haskey(_openapi_object, "names") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["names"], _openapi_validate) : ABSENT + _openapi_field_sizebytes = haskey(_openapi_object, "sizeBytes") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["sizeBytes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("names","sizeBytes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerImage(; names = _openapi_field_names, sizebytes = _openapi_field_sizebytes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerImage) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.names isa Absent || (_openapi_output["names"] = _encode(_openapi_value.names)) + _openapi_value.sizebytes isa Absent || (_openapi_output["sizeBytes"] = _encode(_openapi_value.sizebytes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerImage"), _openapi_output, "encoding IoK8sApiCoreV1ContainerImage"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerImage) + _openapi_output = Pair{String,Any}[] + _openapi_value.names isa Absent || push!(_openapi_output, "names" => _openapi_value.names) + _openapi_value.sizebytes isa Absent || push!(_openapi_output, "sizeBytes" => _openapi_value.sizebytes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerStateRunning + startedat::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerStateRunning}, value) = _decode(IoK8sApiCoreV1ContainerStateRunning, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerStateRunning}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateRunning"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerStateRunning"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerStateRunning") + _openapi_field_startedat = haskey(_openapi_object, "startedAt") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["startedAt"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("startedAt",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerStateRunning(; startedat = _openapi_field_startedat, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerStateRunning) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.startedat isa Absent || (_openapi_output["startedAt"] = _encode(_openapi_value.startedat)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateRunning"), _openapi_output, "encoding IoK8sApiCoreV1ContainerStateRunning"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerStateRunning) + _openapi_output = Pair{String,Any}[] + _openapi_value.startedat isa Absent || push!(_openapi_output, "startedAt" => _openapi_value.startedat) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerStateTerminated + containerid::Union{Absent,Nothing,String} = ABSENT + exitcode::Int32 + finishedat::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + signal::Union{Absent,Int32,Nothing} = ABSENT + startedat::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerStateTerminated}, value) = _decode(IoK8sApiCoreV1ContainerStateTerminated, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerStateTerminated}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerStateTerminated"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerStateTerminated") + _openapi_field_containerid = haskey(_openapi_object, "containerID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerID"], _openapi_validate) : ABSENT + _openapi_field_exitcode = _decode(Int32, _required(_openapi_object, "exitCode", "IoK8sApiCoreV1ContainerStateTerminated"), _openapi_validate) + _openapi_field_finishedat = haskey(_openapi_object, "finishedAt") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["finishedAt"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_signal = haskey(_openapi_object, "signal") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["signal"], _openapi_validate) : ABSENT + _openapi_field_startedat = haskey(_openapi_object, "startedAt") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["startedAt"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("containerID","exitCode","finishedAt","message","reason","signal","startedAt") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerStateTerminated(; containerid = _openapi_field_containerid, exitcode = _openapi_field_exitcode, finishedat = _openapi_field_finishedat, message = _openapi_field_message, reason = _openapi_field_reason, signal = _openapi_field_signal, startedat = _openapi_field_startedat, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerStateTerminated) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.containerid isa Absent || (_openapi_output["containerID"] = _encode(_openapi_value.containerid)) + _openapi_value.exitcode isa Absent || (_openapi_output["exitCode"] = _encode(_openapi_value.exitcode)) + _openapi_value.finishedat isa Absent || (_openapi_output["finishedAt"] = _encode(_openapi_value.finishedat)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.signal isa Absent || (_openapi_output["signal"] = _encode(_openapi_value.signal)) + _openapi_value.startedat isa Absent || (_openapi_output["startedAt"] = _encode(_openapi_value.startedat)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateTerminated"), _openapi_output, "encoding IoK8sApiCoreV1ContainerStateTerminated"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerStateTerminated) + _openapi_output = Pair{String,Any}[] + _openapi_value.containerid isa Absent || push!(_openapi_output, "containerID" => _openapi_value.containerid) + _openapi_value.exitcode isa Absent || push!(_openapi_output, "exitCode" => _openapi_value.exitcode) + _openapi_value.finishedat isa Absent || push!(_openapi_output, "finishedAt" => _openapi_value.finishedat) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.signal isa Absent || push!(_openapi_output, "signal" => _openapi_value.signal) + _openapi_value.startedat isa Absent || push!(_openapi_output, "startedAt" => _openapi_value.startedat) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerStateWaiting + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerStateWaiting}, value) = _decode(IoK8sApiCoreV1ContainerStateWaiting, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerStateWaiting}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerStateWaiting"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerStateWaiting") + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerStateWaiting(; message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerStateWaiting) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStateWaiting"), _openapi_output, "encoding IoK8sApiCoreV1ContainerStateWaiting"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerStateWaiting) + _openapi_output = Pair{String,Any}[] + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerState + running::Union{Absent,IoK8sApiCoreV1ContainerStateRunning,Nothing} = ABSENT + terminated::Union{Absent,IoK8sApiCoreV1ContainerStateTerminated,Nothing} = ABSENT + waiting::Union{Absent,IoK8sApiCoreV1ContainerStateWaiting,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerState}, value) = _decode(IoK8sApiCoreV1ContainerState, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerState}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerState"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerState"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerState") + _openapi_field_running = haskey(_openapi_object, "running") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerStateRunning,Nothing}, _openapi_object["running"], _openapi_validate) : ABSENT + _openapi_field_terminated = haskey(_openapi_object, "terminated") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerStateTerminated,Nothing}, _openapi_object["terminated"], _openapi_validate) : ABSENT + _openapi_field_waiting = haskey(_openapi_object, "waiting") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerStateWaiting,Nothing}, _openapi_object["waiting"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("running","terminated","waiting") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerState(; running = _openapi_field_running, terminated = _openapi_field_terminated, waiting = _openapi_field_waiting, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerState) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.running isa Absent || (_openapi_output["running"] = _encode(_openapi_value.running)) + _openapi_value.terminated isa Absent || (_openapi_output["terminated"] = _encode(_openapi_value.terminated)) + _openapi_value.waiting isa Absent || (_openapi_output["waiting"] = _encode(_openapi_value.waiting)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerState"), _openapi_output, "encoding IoK8sApiCoreV1ContainerState"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerState) + _openapi_output = Pair{String,Any}[] + _openapi_value.running isa Absent || push!(_openapi_output, "running" => _openapi_value.running) + _openapi_value.terminated isa Absent || push!(_openapi_output, "terminated" => _openapi_value.terminated) + _openapi_value.waiting isa Absent || push!(_openapi_output, "waiting" => _openapi_value.waiting) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerStatusAllocatedResources + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ContainerStatusAllocatedResources}, value) = _decode(IoK8sApiCoreV1ContainerStatusAllocatedResources, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerStatusAllocatedResources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStatus/properties/allocatedResources"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerStatusAllocatedResources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerStatusAllocatedResources") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerStatusAllocatedResources(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerStatusAllocatedResources) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStatus/properties/allocatedResources"), _openapi_output, "encoding IoK8sApiCoreV1ContainerStatusAllocatedResources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerStatusAllocatedResources) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceHealth + health::Union{Absent,Nothing,String} = ABSENT + resourceid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceHealth}, value) = _decode(IoK8sApiCoreV1ResourceHealth, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceHealth}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceHealth"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceHealth"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceHealth") + _openapi_field_health = haskey(_openapi_object, "health") ? _decode(Union{Absent,Nothing,String}, _openapi_object["health"], _openapi_validate) : ABSENT + _openapi_field_resourceid = _decode(String, _required(_openapi_object, "resourceID", "IoK8sApiCoreV1ResourceHealth"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("health","resourceID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceHealth(; health = _openapi_field_health, resourceid = _openapi_field_resourceid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceHealth) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.health isa Absent || (_openapi_output["health"] = _encode(_openapi_value.health)) + _openapi_value.resourceid isa Absent || (_openapi_output["resourceID"] = _encode(_openapi_value.resourceid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceHealth"), _openapi_output, "encoding IoK8sApiCoreV1ResourceHealth"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceHealth) + _openapi_output = Pair{String,Any}[] + _openapi_value.health isa Absent || push!(_openapi_output, "health" => _openapi_value.health) + _openapi_value.resourceid isa Absent || push!(_openapi_output, "resourceID" => _openapi_value.resourceid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceStatus + name::String + resources::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceHealth}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceStatus}, value) = _decode(IoK8sApiCoreV1ResourceStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceStatus") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ResourceStatus"), _openapi_validate) + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceHealth}}}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceStatus(; name = _openapi_field_name, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceStatus"), _openapi_output, "encoding IoK8sApiCoreV1ResourceStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LinuxContainerUser + gid::Int64 + supplementalgroups::Union{Absent,Union{Nothing,Vector{Int64}}} = ABSENT + uid::Int64 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LinuxContainerUser}, value) = _decode(IoK8sApiCoreV1LinuxContainerUser, value, true) +function _decode(::Type{IoK8sApiCoreV1LinuxContainerUser}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LinuxContainerUser"), _openapi_raw, "decoding IoK8sApiCoreV1LinuxContainerUser"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LinuxContainerUser") + _openapi_field_gid = _decode(Int64, _required(_openapi_object, "gid", "IoK8sApiCoreV1LinuxContainerUser"), _openapi_validate) + _openapi_field_supplementalgroups = haskey(_openapi_object, "supplementalGroups") ? _decode(Union{Absent,Union{Nothing,Vector{Int64}}}, _openapi_object["supplementalGroups"], _openapi_validate) : ABSENT + _openapi_field_uid = _decode(Int64, _required(_openapi_object, "uid", "IoK8sApiCoreV1LinuxContainerUser"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("gid","supplementalGroups","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LinuxContainerUser(; gid = _openapi_field_gid, supplementalgroups = _openapi_field_supplementalgroups, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LinuxContainerUser) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.gid isa Absent || (_openapi_output["gid"] = _encode(_openapi_value.gid)) + _openapi_value.supplementalgroups isa Absent || (_openapi_output["supplementalGroups"] = _encode(_openapi_value.supplementalgroups)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LinuxContainerUser"), _openapi_output, "encoding IoK8sApiCoreV1LinuxContainerUser"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LinuxContainerUser) + _openapi_output = Pair{String,Any}[] + _openapi_value.gid isa Absent || push!(_openapi_output, "gid" => _openapi_value.gid) + _openapi_value.supplementalgroups isa Absent || push!(_openapi_output, "supplementalGroups" => _openapi_value.supplementalgroups) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerUser + linux::Union{Absent,IoK8sApiCoreV1LinuxContainerUser,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerUser}, value) = _decode(IoK8sApiCoreV1ContainerUser, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerUser}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerUser"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerUser"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerUser") + _openapi_field_linux = haskey(_openapi_object, "linux") ? _decode(Union{Absent,IoK8sApiCoreV1LinuxContainerUser,Nothing}, _openapi_object["linux"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("linux",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerUser(; linux = _openapi_field_linux, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerUser) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.linux isa Absent || (_openapi_output["linux"] = _encode(_openapi_value.linux)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerUser"), _openapi_output, "encoding IoK8sApiCoreV1ContainerUser"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerUser) + _openapi_output = Pair{String,Any}[] + _openapi_value.linux isa Absent || push!(_openapi_output, "linux" => _openapi_value.linux) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeMountStatus + mountpath::String + name::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + recursivereadonly::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeMountStatus}, value) = _decode(IoK8sApiCoreV1VolumeMountStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeMountStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMountStatus"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeMountStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeMountStatus") + _openapi_field_mountpath = _decode(String, _required(_openapi_object, "mountPath", "IoK8sApiCoreV1VolumeMountStatus"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1VolumeMountStatus"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_recursivereadonly = haskey(_openapi_object, "recursiveReadOnly") ? _decode(Union{Absent,Nothing,String}, _openapi_object["recursiveReadOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("mountPath","name","readOnly","recursiveReadOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeMountStatus(; mountpath = _openapi_field_mountpath, name = _openapi_field_name, readonly = _openapi_field_readonly, recursivereadonly = _openapi_field_recursivereadonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeMountStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.mountpath isa Absent || (_openapi_output["mountPath"] = _encode(_openapi_value.mountpath)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.recursivereadonly isa Absent || (_openapi_output["recursiveReadOnly"] = _encode(_openapi_value.recursivereadonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeMountStatus"), _openapi_output, "encoding IoK8sApiCoreV1VolumeMountStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeMountStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.mountpath isa Absent || push!(_openapi_output, "mountPath" => _openapi_value.mountpath) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.recursivereadonly isa Absent || push!(_openapi_output, "recursiveReadOnly" => _openapi_value.recursivereadonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ContainerStatus + allocatedresources::Union{Absent,IoK8sApiCoreV1ContainerStatusAllocatedResources,Nothing} = ABSENT + allocatedresourcesstatus::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceStatus}}} = ABSENT + containerid::Union{Absent,Nothing,String} = ABSENT + image::String + imageid::String + laststate::Union{Absent,IoK8sApiCoreV1ContainerState,Nothing} = ABSENT + name::String + ready::Bool + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartcount::Int32 + started::Union{Absent,Bool,Nothing} = ABSENT + state::Union{Absent,IoK8sApiCoreV1ContainerState,Nothing} = ABSENT + stopsignal::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,IoK8sApiCoreV1ContainerUser,Nothing} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMountStatus}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ContainerStatus}, value) = _decode(IoK8sApiCoreV1ContainerStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ContainerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ContainerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ContainerStatus") + _openapi_field_allocatedresources = haskey(_openapi_object, "allocatedResources") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerStatusAllocatedResources,Nothing}, _openapi_object["allocatedResources"], _openapi_validate) : ABSENT + _openapi_field_allocatedresourcesstatus = haskey(_openapi_object, "allocatedResourcesStatus") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ResourceStatus}}}, _openapi_object["allocatedResourcesStatus"], _openapi_validate) : ABSENT + _openapi_field_containerid = haskey(_openapi_object, "containerID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["containerID"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1ContainerStatus"), _openapi_validate) + _openapi_field_imageid = _decode(String, _required(_openapi_object, "imageID", "IoK8sApiCoreV1ContainerStatus"), _openapi_validate) + _openapi_field_laststate = haskey(_openapi_object, "lastState") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerState,Nothing}, _openapi_object["lastState"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1ContainerStatus"), _openapi_validate) + _openapi_field_ready = _decode(Bool, _required(_openapi_object, "ready", "IoK8sApiCoreV1ContainerStatus"), _openapi_validate) + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartcount = _decode(Int32, _required(_openapi_object, "restartCount", "IoK8sApiCoreV1ContainerStatus"), _openapi_validate) + _openapi_field_started = haskey(_openapi_object, "started") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["started"], _openapi_validate) : ABSENT + _openapi_field_state = haskey(_openapi_object, "state") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerState,Nothing}, _openapi_object["state"], _openapi_validate) : ABSENT + _openapi_field_stopsignal = haskey(_openapi_object, "stopSignal") ? _decode(Union{Absent,Nothing,String}, _openapi_object["stopSignal"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,IoK8sApiCoreV1ContainerUser,Nothing}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMountStatus}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allocatedResources","allocatedResourcesStatus","containerID","image","imageID","lastState","name","ready","resources","restartCount","started","state","stopSignal","user","volumeMounts") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ContainerStatus(; allocatedresources = _openapi_field_allocatedresources, allocatedresourcesstatus = _openapi_field_allocatedresourcesstatus, containerid = _openapi_field_containerid, image = _openapi_field_image, imageid = _openapi_field_imageid, laststate = _openapi_field_laststate, name = _openapi_field_name, ready = _openapi_field_ready, resources = _openapi_field_resources, restartcount = _openapi_field_restartcount, started = _openapi_field_started, state = _openapi_field_state, stopsignal = _openapi_field_stopsignal, user = _openapi_field_user, volumemounts = _openapi_field_volumemounts, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ContainerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allocatedresources isa Absent || (_openapi_output["allocatedResources"] = _encode(_openapi_value.allocatedresources)) + _openapi_value.allocatedresourcesstatus isa Absent || (_openapi_output["allocatedResourcesStatus"] = _encode(_openapi_value.allocatedresourcesstatus)) + _openapi_value.containerid isa Absent || (_openapi_output["containerID"] = _encode(_openapi_value.containerid)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imageid isa Absent || (_openapi_output["imageID"] = _encode(_openapi_value.imageid)) + _openapi_value.laststate isa Absent || (_openapi_output["lastState"] = _encode(_openapi_value.laststate)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ready isa Absent || (_openapi_output["ready"] = _encode(_openapi_value.ready)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartcount isa Absent || (_openapi_output["restartCount"] = _encode(_openapi_value.restartcount)) + _openapi_value.started isa Absent || (_openapi_output["started"] = _encode(_openapi_value.started)) + _openapi_value.state isa Absent || (_openapi_output["state"] = _encode(_openapi_value.state)) + _openapi_value.stopsignal isa Absent || (_openapi_output["stopSignal"] = _encode(_openapi_value.stopsignal)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ContainerStatus"), _openapi_output, "encoding IoK8sApiCoreV1ContainerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ContainerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.allocatedresources isa Absent || push!(_openapi_output, "allocatedResources" => _openapi_value.allocatedresources) + _openapi_value.allocatedresourcesstatus isa Absent || push!(_openapi_output, "allocatedResourcesStatus" => _openapi_value.allocatedresourcesstatus) + _openapi_value.containerid isa Absent || push!(_openapi_output, "containerID" => _openapi_value.containerid) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imageid isa Absent || push!(_openapi_output, "imageID" => _openapi_value.imageid) + _openapi_value.laststate isa Absent || push!(_openapi_output, "lastState" => _openapi_value.laststate) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ready isa Absent || push!(_openapi_output, "ready" => _openapi_value.ready) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartcount isa Absent || push!(_openapi_output, "restartCount" => _openapi_value.restartcount) + _openapi_value.started isa Absent || push!(_openapi_output, "started" => _openapi_value.started) + _openapi_value.state isa Absent || push!(_openapi_output, "state" => _openapi_value.state) + _openapi_value.stopsignal isa Absent || push!(_openapi_output, "stopSignal" => _openapi_value.stopsignal) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DaemonEndpoint + port::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DaemonEndpoint}, value) = _decode(IoK8sApiCoreV1DaemonEndpoint, value, true) +function _decode(::Type{IoK8sApiCoreV1DaemonEndpoint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DaemonEndpoint"), _openapi_raw, "decoding IoK8sApiCoreV1DaemonEndpoint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DaemonEndpoint") + _openapi_field_port = _decode(Int32, _required(_openapi_object, "Port", "IoK8sApiCoreV1DaemonEndpoint"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("Port",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DaemonEndpoint(; port = _openapi_field_port, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DaemonEndpoint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.port isa Absent || (_openapi_output["Port"] = _encode(_openapi_value.port)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DaemonEndpoint"), _openapi_output, "encoding IoK8sApiCoreV1DaemonEndpoint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DaemonEndpoint) + _openapi_output = Pair{String,Any}[] + _openapi_value.port isa Absent || push!(_openapi_output, "Port" => _openapi_value.port) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeFile + fieldref::Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing} = ABSENT + mode::Union{Absent,Int32,Nothing} = ABSENT + path::String + resourcefieldref::Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeFile, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeFile}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeFile") + _openapi_field_fieldref = haskey(_openapi_object, "fieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectFieldSelector,Nothing}, _openapi_object["fieldRef"], _openapi_validate) : ABSENT + _openapi_field_mode = haskey(_openapi_object, "mode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["mode"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1DownwardAPIVolumeFile"), _openapi_validate) + _openapi_field_resourcefieldref = haskey(_openapi_object, "resourceFieldRef") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceFieldSelector,Nothing}, _openapi_object["resourceFieldRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fieldRef","mode","path","resourceFieldRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeFile(; fieldref = _openapi_field_fieldref, mode = _openapi_field_mode, path = _openapi_field_path, resourcefieldref = _openapi_field_resourcefieldref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fieldref isa Absent || (_openapi_output["fieldRef"] = _encode(_openapi_value.fieldref)) + _openapi_value.mode isa Absent || (_openapi_output["mode"] = _encode(_openapi_value.mode)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.resourcefieldref isa Absent || (_openapi_output["resourceFieldRef"] = _encode(_openapi_value.resourcefieldref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeFile"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeFile"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeFile) + _openapi_output = Pair{String,Any}[] + _openapi_value.fieldref isa Absent || push!(_openapi_output, "fieldRef" => _openapi_value.fieldref) + _openapi_value.mode isa Absent || push!(_openapi_output, "mode" => _openapi_value.mode) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.resourcefieldref isa Absent || push!(_openapi_output, "resourceFieldRef" => _openapi_value.resourcefieldref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, value) = _decode(IoK8sApiCoreV1DownwardAPIProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIProjection(; items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIProjection"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1DownwardAPIVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, value) = _decode(IoK8sApiCoreV1DownwardAPIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1DownwardAPIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1DownwardAPIVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1DownwardAPIVolumeFile}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1DownwardAPIVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.DownwardAPIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1DownwardAPIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1DownwardAPIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EmptyDirVolumeSource + medium::Union{Absent,Nothing,String} = ABSENT + sizelimit::Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, value) = _decode(IoK8sApiCoreV1EmptyDirVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EmptyDirVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EmptyDirVolumeSource") + _openapi_field_medium = haskey(_openapi_object, "medium") ? _decode(Union{Absent,Nothing,String}, _openapi_object["medium"], _openapi_validate) : ABSENT + _openapi_field_sizelimit = haskey(_openapi_object, "sizeLimit") ? _decode(Union{Absent,IoK8sApimachineryPkgApiResourceQuantity,Nothing}, _openapi_object["sizeLimit"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("medium","sizeLimit") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EmptyDirVolumeSource(; medium = _openapi_field_medium, sizelimit = _openapi_field_sizelimit, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.medium isa Absent || (_openapi_output["medium"] = _encode(_openapi_value.medium)) + _openapi_value.sizelimit isa Absent || (_openapi_output["sizeLimit"] = _encode(_openapi_value.sizelimit)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EmptyDirVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EmptyDirVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EmptyDirVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.medium isa Absent || push!(_openapi_output, "medium" => _openapi_value.medium) + _openapi_value.sizelimit isa Absent || push!(_openapi_output, "sizeLimit" => _openapi_value.sizelimit) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EndpointAddress + hostname::Union{Absent,Nothing,String} = ABSENT + ip::String + nodename::Union{Absent,Nothing,String} = ABSENT + targetref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EndpointAddress}, value) = _decode(IoK8sApiCoreV1EndpointAddress, value, true) +function _decode(::Type{IoK8sApiCoreV1EndpointAddress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointAddress"), _openapi_raw, "decoding IoK8sApiCoreV1EndpointAddress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EndpointAddress") + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1EndpointAddress"), _openapi_validate) + _openapi_field_nodename = haskey(_openapi_object, "nodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeName"], _openapi_validate) : ABSENT + _openapi_field_targetref = haskey(_openapi_object, "targetRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["targetRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostname","ip","nodeName","targetRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EndpointAddress(; hostname = _openapi_field_hostname, ip = _openapi_field_ip, nodename = _openapi_field_nodename, targetref = _openapi_field_targetref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EndpointAddress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.targetref isa Absent || (_openapi_output["targetRef"] = _encode(_openapi_value.targetref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointAddress"), _openapi_output, "encoding IoK8sApiCoreV1EndpointAddress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EndpointAddress) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.targetref isa Absent || push!(_openapi_output, "targetRef" => _openapi_value.targetref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EndpointPort + appprotocol::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + port::Int32 + protocol::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EndpointPort}, value) = _decode(IoK8sApiCoreV1EndpointPort, value, true) +function _decode(::Type{IoK8sApiCoreV1EndpointPort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointPort"), _openapi_raw, "decoding IoK8sApiCoreV1EndpointPort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EndpointPort") + _openapi_field_appprotocol = haskey(_openapi_object, "appProtocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["appProtocol"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1EndpointPort"), _openapi_validate) + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appProtocol","name","port","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EndpointPort(; appprotocol = _openapi_field_appprotocol, name = _openapi_field_name, port = _openapi_field_port, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EndpointPort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.appprotocol isa Absent || (_openapi_output["appProtocol"] = _encode(_openapi_value.appprotocol)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointPort"), _openapi_output, "encoding IoK8sApiCoreV1EndpointPort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EndpointPort) + _openapi_output = Pair{String,Any}[] + _openapi_value.appprotocol isa Absent || push!(_openapi_output, "appProtocol" => _openapi_value.appprotocol) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EndpointSubset + addresses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointAddress}}} = ABSENT + notreadyaddresses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointAddress}}} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointPort}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EndpointSubset}, value) = _decode(IoK8sApiCoreV1EndpointSubset, value, true) +function _decode(::Type{IoK8sApiCoreV1EndpointSubset}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointSubset"), _openapi_raw, "decoding IoK8sApiCoreV1EndpointSubset"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EndpointSubset") + _openapi_field_addresses = haskey(_openapi_object, "addresses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointAddress}}}, _openapi_object["addresses"], _openapi_validate) : ABSENT + _openapi_field_notreadyaddresses = haskey(_openapi_object, "notReadyAddresses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointAddress}}}, _openapi_object["notReadyAddresses"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("addresses","notReadyAddresses","ports") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EndpointSubset(; addresses = _openapi_field_addresses, notreadyaddresses = _openapi_field_notreadyaddresses, ports = _openapi_field_ports, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EndpointSubset) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.addresses isa Absent || (_openapi_output["addresses"] = _encode(_openapi_value.addresses)) + _openapi_value.notreadyaddresses isa Absent || (_openapi_output["notReadyAddresses"] = _encode(_openapi_value.notreadyaddresses)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointSubset"), _openapi_output, "encoding IoK8sApiCoreV1EndpointSubset"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EndpointSubset) + _openapi_output = Pair{String,Any}[] + _openapi_value.addresses isa Absent || push!(_openapi_output, "addresses" => _openapi_value.addresses) + _openapi_value.notreadyaddresses isa Absent || push!(_openapi_output, "notReadyAddresses" => _openapi_value.notreadyaddresses) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Endpoints + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + subsets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointSubset}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Endpoints}, value) = _decode(IoK8sApiCoreV1Endpoints, value, true) +function _decode(::Type{IoK8sApiCoreV1Endpoints}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Endpoints"), _openapi_raw, "decoding IoK8sApiCoreV1Endpoints"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Endpoints") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_subsets = haskey(_openapi_object, "subsets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EndpointSubset}}}, _openapi_object["subsets"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","subsets") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Endpoints(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, subsets = _openapi_field_subsets, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Endpoints) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.subsets isa Absent || (_openapi_output["subsets"] = _encode(_openapi_value.subsets)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Endpoints"), _openapi_output, "encoding IoK8sApiCoreV1Endpoints"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Endpoints) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.subsets isa Absent || push!(_openapi_output, "subsets" => _openapi_value.subsets) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EndpointsList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Endpoints}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EndpointsList}, value) = _decode(IoK8sApiCoreV1EndpointsList, value, true) +function _decode(::Type{IoK8sApiCoreV1EndpointsList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointsList"), _openapi_raw, "decoding IoK8sApiCoreV1EndpointsList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EndpointsList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Endpoints}}, _required(_openapi_object, "items", "IoK8sApiCoreV1EndpointsList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EndpointsList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EndpointsList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EndpointsList"), _openapi_output, "encoding IoK8sApiCoreV1EndpointsList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EndpointsList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralContainer + args::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + command::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + env::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}} = ABSENT + envfrom::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}} = ABSENT + image::Union{Absent,Nothing,String} = ABSENT + imagepullpolicy::Union{Absent,Nothing,String} = ABSENT + lifecycle::Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing} = ABSENT + livenessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + name::String + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}} = ABSENT + readinessprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + resizepolicy::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + restartpolicyrules::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing} = ABSENT + startupprobe::Union{Absent,IoK8sApiCoreV1Probe,Nothing} = ABSENT + stdin::Union{Absent,Bool,Nothing} = ABSENT + stdinonce::Union{Absent,Bool,Nothing} = ABSENT + targetcontainername::Union{Absent,Nothing,String} = ABSENT + terminationmessagepath::Union{Absent,Nothing,String} = ABSENT + terminationmessagepolicy::Union{Absent,Nothing,String} = ABSENT + tty::Union{Absent,Bool,Nothing} = ABSENT + volumedevices::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}} = ABSENT + volumemounts::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}} = ABSENT + workingdir::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralContainer}, value) = _decode(IoK8sApiCoreV1EphemeralContainer, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralContainer}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralContainer") + _openapi_field_args = haskey(_openapi_object, "args") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["args"], _openapi_validate) : ABSENT + _openapi_field_command = haskey(_openapi_object, "command") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["command"], _openapi_validate) : ABSENT + _openapi_field_env = haskey(_openapi_object, "env") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvVar}}}, _openapi_object["env"], _openapi_validate) : ABSENT + _openapi_field_envfrom = haskey(_openapi_object, "envFrom") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EnvFromSource}}}, _openapi_object["envFrom"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,Nothing,String}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_imagepullpolicy = haskey(_openapi_object, "imagePullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["imagePullPolicy"], _openapi_validate) : ABSENT + _openapi_field_lifecycle = haskey(_openapi_object, "lifecycle") ? _decode(Union{Absent,IoK8sApiCoreV1Lifecycle,Nothing}, _openapi_object["lifecycle"], _openapi_validate) : ABSENT + _openapi_field_livenessprobe = haskey(_openapi_object, "livenessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["livenessProbe"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1EphemeralContainer"), _openapi_validate) + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerPort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_readinessprobe = haskey(_openapi_object, "readinessProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["readinessProbe"], _openapi_validate) : ABSENT + _openapi_field_resizepolicy = haskey(_openapi_object, "resizePolicy") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerResizePolicy}}}, _openapi_object["resizePolicy"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_restartpolicyrules = haskey(_openapi_object, "restartPolicyRules") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerRestartRule}}}, _openapi_object["restartPolicyRules"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1SecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_startupprobe = haskey(_openapi_object, "startupProbe") ? _decode(Union{Absent,IoK8sApiCoreV1Probe,Nothing}, _openapi_object["startupProbe"], _openapi_validate) : ABSENT + _openapi_field_stdin = haskey(_openapi_object, "stdin") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdin"], _openapi_validate) : ABSENT + _openapi_field_stdinonce = haskey(_openapi_object, "stdinOnce") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["stdinOnce"], _openapi_validate) : ABSENT + _openapi_field_targetcontainername = haskey(_openapi_object, "targetContainerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["targetContainerName"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepath = haskey(_openapi_object, "terminationMessagePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePath"], _openapi_validate) : ABSENT + _openapi_field_terminationmessagepolicy = haskey(_openapi_object, "terminationMessagePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["terminationMessagePolicy"], _openapi_validate) : ABSENT + _openapi_field_tty = haskey(_openapi_object, "tty") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["tty"], _openapi_validate) : ABSENT + _openapi_field_volumedevices = haskey(_openapi_object, "volumeDevices") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeDevice}}}, _openapi_object["volumeDevices"], _openapi_validate) : ABSENT + _openapi_field_volumemounts = haskey(_openapi_object, "volumeMounts") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeMount}}}, _openapi_object["volumeMounts"], _openapi_validate) : ABSENT + _openapi_field_workingdir = haskey(_openapi_object, "workingDir") ? _decode(Union{Absent,Nothing,String}, _openapi_object["workingDir"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("args","command","env","envFrom","image","imagePullPolicy","lifecycle","livenessProbe","name","ports","readinessProbe","resizePolicy","resources","restartPolicy","restartPolicyRules","securityContext","startupProbe","stdin","stdinOnce","targetContainerName","terminationMessagePath","terminationMessagePolicy","tty","volumeDevices","volumeMounts","workingDir") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralContainer(; args = _openapi_field_args, command = _openapi_field_command, env = _openapi_field_env, envfrom = _openapi_field_envfrom, image = _openapi_field_image, imagepullpolicy = _openapi_field_imagepullpolicy, lifecycle = _openapi_field_lifecycle, livenessprobe = _openapi_field_livenessprobe, name = _openapi_field_name, ports = _openapi_field_ports, readinessprobe = _openapi_field_readinessprobe, resizepolicy = _openapi_field_resizepolicy, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, restartpolicyrules = _openapi_field_restartpolicyrules, securitycontext = _openapi_field_securitycontext, startupprobe = _openapi_field_startupprobe, stdin = _openapi_field_stdin, stdinonce = _openapi_field_stdinonce, targetcontainername = _openapi_field_targetcontainername, terminationmessagepath = _openapi_field_terminationmessagepath, terminationmessagepolicy = _openapi_field_terminationmessagepolicy, tty = _openapi_field_tty, volumedevices = _openapi_field_volumedevices, volumemounts = _openapi_field_volumemounts, workingdir = _openapi_field_workingdir, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.args isa Absent || (_openapi_output["args"] = _encode(_openapi_value.args)) + _openapi_value.command isa Absent || (_openapi_output["command"] = _encode(_openapi_value.command)) + _openapi_value.env isa Absent || (_openapi_output["env"] = _encode(_openapi_value.env)) + _openapi_value.envfrom isa Absent || (_openapi_output["envFrom"] = _encode(_openapi_value.envfrom)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.imagepullpolicy isa Absent || (_openapi_output["imagePullPolicy"] = _encode(_openapi_value.imagepullpolicy)) + _openapi_value.lifecycle isa Absent || (_openapi_output["lifecycle"] = _encode(_openapi_value.lifecycle)) + _openapi_value.livenessprobe isa Absent || (_openapi_output["livenessProbe"] = _encode(_openapi_value.livenessprobe)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.readinessprobe isa Absent || (_openapi_output["readinessProbe"] = _encode(_openapi_value.readinessprobe)) + _openapi_value.resizepolicy isa Absent || (_openapi_output["resizePolicy"] = _encode(_openapi_value.resizepolicy)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.restartpolicyrules isa Absent || (_openapi_output["restartPolicyRules"] = _encode(_openapi_value.restartpolicyrules)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.startupprobe isa Absent || (_openapi_output["startupProbe"] = _encode(_openapi_value.startupprobe)) + _openapi_value.stdin isa Absent || (_openapi_output["stdin"] = _encode(_openapi_value.stdin)) + _openapi_value.stdinonce isa Absent || (_openapi_output["stdinOnce"] = _encode(_openapi_value.stdinonce)) + _openapi_value.targetcontainername isa Absent || (_openapi_output["targetContainerName"] = _encode(_openapi_value.targetcontainername)) + _openapi_value.terminationmessagepath isa Absent || (_openapi_output["terminationMessagePath"] = _encode(_openapi_value.terminationmessagepath)) + _openapi_value.terminationmessagepolicy isa Absent || (_openapi_output["terminationMessagePolicy"] = _encode(_openapi_value.terminationmessagepolicy)) + _openapi_value.tty isa Absent || (_openapi_output["tty"] = _encode(_openapi_value.tty)) + _openapi_value.volumedevices isa Absent || (_openapi_output["volumeDevices"] = _encode(_openapi_value.volumedevices)) + _openapi_value.volumemounts isa Absent || (_openapi_output["volumeMounts"] = _encode(_openapi_value.volumemounts)) + _openapi_value.workingdir isa Absent || (_openapi_output["workingDir"] = _encode(_openapi_value.workingdir)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralContainer"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralContainer"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralContainer) + _openapi_output = Pair{String,Any}[] + _openapi_value.args isa Absent || push!(_openapi_output, "args" => _openapi_value.args) + _openapi_value.command isa Absent || push!(_openapi_output, "command" => _openapi_value.command) + _openapi_value.env isa Absent || push!(_openapi_output, "env" => _openapi_value.env) + _openapi_value.envfrom isa Absent || push!(_openapi_output, "envFrom" => _openapi_value.envfrom) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.imagepullpolicy isa Absent || push!(_openapi_output, "imagePullPolicy" => _openapi_value.imagepullpolicy) + _openapi_value.lifecycle isa Absent || push!(_openapi_output, "lifecycle" => _openapi_value.lifecycle) + _openapi_value.livenessprobe isa Absent || push!(_openapi_output, "livenessProbe" => _openapi_value.livenessprobe) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.readinessprobe isa Absent || push!(_openapi_output, "readinessProbe" => _openapi_value.readinessprobe) + _openapi_value.resizepolicy isa Absent || push!(_openapi_output, "resizePolicy" => _openapi_value.resizepolicy) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.restartpolicyrules isa Absent || push!(_openapi_output, "restartPolicyRules" => _openapi_value.restartpolicyrules) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.startupprobe isa Absent || push!(_openapi_output, "startupProbe" => _openapi_value.startupprobe) + _openapi_value.stdin isa Absent || push!(_openapi_output, "stdin" => _openapi_value.stdin) + _openapi_value.stdinonce isa Absent || push!(_openapi_output, "stdinOnce" => _openapi_value.stdinonce) + _openapi_value.targetcontainername isa Absent || push!(_openapi_output, "targetContainerName" => _openapi_value.targetcontainername) + _openapi_value.terminationmessagepath isa Absent || push!(_openapi_output, "terminationMessagePath" => _openapi_value.terminationmessagepath) + _openapi_value.terminationmessagepolicy isa Absent || push!(_openapi_output, "terminationMessagePolicy" => _openapi_value.terminationmessagepolicy) + _openapi_value.tty isa Absent || push!(_openapi_output, "tty" => _openapi_value.tty) + _openapi_value.volumedevices isa Absent || push!(_openapi_output, "volumeDevices" => _openapi_value.volumedevices) + _openapi_value.volumemounts isa Absent || push!(_openapi_output, "volumeMounts" => _openapi_value.volumemounts) + _openapi_value.workingdir isa Absent || push!(_openapi_output, "workingDir" => _openapi_value.workingdir) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedLocalObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, value) = _decode(IoK8sApiCoreV1TypedLocalObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedLocalObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedLocalObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedLocalObjectReference"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedLocalObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedLocalObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedLocalObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TypedObjectReference + apigroup::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TypedObjectReference}, value) = _decode(IoK8sApiCoreV1TypedObjectReference, value, true) +function _decode(::Type{IoK8sApiCoreV1TypedObjectReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_raw, "decoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TypedObjectReference") + _openapi_field_apigroup = haskey(_openapi_object, "apiGroup") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiGroup"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1TypedObjectReference"), _openapi_validate) + _openapi_field_namespace = haskey(_openapi_object, "namespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["namespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiGroup","kind","name","namespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TypedObjectReference(; apigroup = _openapi_field_apigroup, kind = _openapi_field_kind, name = _openapi_field_name, namespace = _openapi_field_namespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apigroup isa Absent || (_openapi_output["apiGroup"] = _encode(_openapi_value.apigroup)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespace isa Absent || (_openapi_output["namespace"] = _encode(_openapi_value.namespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TypedObjectReference"), _openapi_output, "encoding IoK8sApiCoreV1TypedObjectReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TypedObjectReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.apigroup isa Absent || push!(_openapi_output, "apiGroup" => _openapi_value.apigroup) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespace isa Absent || push!(_openapi_output, "namespace" => _openapi_value.namespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsLimits + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsLimits, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsLimits}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsLimits") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsLimits(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/limits"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsLimits"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsLimits) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirementsRequests + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirementsRequests, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirementsRequests}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirementsRequests") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirementsRequests(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements/properties/requests"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirementsRequests"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirementsRequests) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeResourceRequirements + limits::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing} = ABSENT + requests::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, value) = _decode(IoK8sApiCoreV1VolumeResourceRequirements, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeResourceRequirements}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeResourceRequirements") + _openapi_field_limits = haskey(_openapi_object, "limits") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsLimits,Nothing}, _openapi_object["limits"], _openapi_validate) : ABSENT + _openapi_field_requests = haskey(_openapi_object, "requests") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirementsRequests,Nothing}, _openapi_object["requests"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("limits","requests") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeResourceRequirements(; limits = _openapi_field_limits, requests = _openapi_field_requests, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + _openapi_value.requests isa Absent || (_openapi_output["requests"] = _encode(_openapi_value.requests)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeResourceRequirements"), _openapi_output, "encoding IoK8sApiCoreV1VolumeResourceRequirements"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeResourceRequirements) + _openapi_output = Pair{String,Any}[] + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + _openapi_value.requests isa Absent || push!(_openapi_output, "requests" => _openapi_value.requests) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimSpec + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + datasource::Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing} = ABSENT + datasourceref::Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing} = ABSENT + selector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + storageclassname::Union{Absent,Nothing,String} = ABSENT + volumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + volumemode::Union{Absent,Nothing,String} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimSpec") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_datasource = haskey(_openapi_object, "dataSource") ? _decode(Union{Absent,IoK8sApiCoreV1TypedLocalObjectReference,Nothing}, _openapi_object["dataSource"], _openapi_validate) : ABSENT + _openapi_field_datasourceref = haskey(_openapi_object, "dataSourceRef") ? _decode(Union{Absent,IoK8sApiCoreV1TypedObjectReference,Nothing}, _openapi_object["dataSourceRef"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = haskey(_openapi_object, "storageClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageClassName"], _openapi_validate) : ABSENT + _openapi_field_volumeattributesclassname = haskey(_openapi_object, "volumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_volumemode = haskey(_openapi_object, "volumeMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeMode"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","dataSource","dataSourceRef","resources","selector","storageClassName","volumeAttributesClassName","volumeMode","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimSpec(; accessmodes = _openapi_field_accessmodes, datasource = _openapi_field_datasource, datasourceref = _openapi_field_datasourceref, resources = _openapi_field_resources, selector = _openapi_field_selector, storageclassname = _openapi_field_storageclassname, volumeattributesclassname = _openapi_field_volumeattributesclassname, volumemode = _openapi_field_volumemode, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.datasource isa Absent || (_openapi_output["dataSource"] = _encode(_openapi_value.datasource)) + _openapi_value.datasourceref isa Absent || (_openapi_output["dataSourceRef"] = _encode(_openapi_value.datasourceref)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + _openapi_value.volumeattributesclassname isa Absent || (_openapi_output["volumeAttributesClassName"] = _encode(_openapi_value.volumeattributesclassname)) + _openapi_value.volumemode isa Absent || (_openapi_output["volumeMode"] = _encode(_openapi_value.volumemode)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimSpec"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.datasource isa Absent || push!(_openapi_output, "dataSource" => _openapi_value.datasource) + _openapi_value.datasourceref isa Absent || push!(_openapi_output, "dataSourceRef" => _openapi_value.datasourceref) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + _openapi_value.volumeattributesclassname isa Absent || push!(_openapi_output, "volumeAttributesClassName" => _openapi_value.volumeattributesclassname) + _openapi_value.volumemode isa Absent || push!(_openapi_output, "volumeMode" => _openapi_value.volumemode) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimTemplate + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::IoK8sApiCoreV1PersistentVolumeClaimSpec + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimTemplate, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimTemplate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimTemplate") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = _decode(IoK8sApiCoreV1PersistentVolumeClaimSpec, _required(_openapi_object, "spec", "IoK8sApiCoreV1PersistentVolumeClaimTemplate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimTemplate(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimTemplate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimTemplate) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EphemeralVolumeSource + volumeclaimtemplate::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, value) = _decode(IoK8sApiCoreV1EphemeralVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EphemeralVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EphemeralVolumeSource") + _openapi_field_volumeclaimtemplate = haskey(_openapi_object, "volumeClaimTemplate") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimTemplate,Nothing}, _openapi_object["volumeClaimTemplate"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("volumeClaimTemplate",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EphemeralVolumeSource(; volumeclaimtemplate = _openapi_field_volumeclaimtemplate, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.volumeclaimtemplate isa Absent || (_openapi_output["volumeClaimTemplate"] = _encode(_openapi_value.volumeclaimtemplate)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EphemeralVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1EphemeralVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EphemeralVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.volumeclaimtemplate isa Absent || push!(_openapi_output, "volumeClaimTemplate" => _openapi_value.volumeclaimtemplate) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1MicroTime = Union{Dates.DateTime,Nothing} + +Base.@kwdef struct IoK8sApiCoreV1EventSeries + count::Union{Absent,Int32,Nothing} = ABSENT + lastobservedtime::Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EventSeries}, value) = _decode(IoK8sApiCoreV1EventSeries, value, true) +function _decode(::Type{IoK8sApiCoreV1EventSeries}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSeries"), _openapi_raw, "decoding IoK8sApiCoreV1EventSeries"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EventSeries") + _openapi_field_count = haskey(_openapi_object, "count") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["count"], _openapi_validate) : ABSENT + _openapi_field_lastobservedtime = haskey(_openapi_object, "lastObservedTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _openapi_object["lastObservedTime"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("count","lastObservedTime") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EventSeries(; count = _openapi_field_count, lastobservedtime = _openapi_field_lastobservedtime, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EventSeries) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.count isa Absent || (_openapi_output["count"] = _encode(_openapi_value.count)) + _openapi_value.lastobservedtime isa Absent || (_openapi_output["lastObservedTime"] = _encode(_openapi_value.lastobservedtime)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSeries"), _openapi_output, "encoding IoK8sApiCoreV1EventSeries"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EventSeries) + _openapi_output = Pair{String,Any}[] + _openapi_value.count isa Absent || push!(_openapi_output, "count" => _openapi_value.count) + _openapi_value.lastobservedtime isa Absent || push!(_openapi_output, "lastObservedTime" => _openapi_value.lastobservedtime) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EventSource + component::Union{Absent,Nothing,String} = ABSENT + host::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EventSource}, value) = _decode(IoK8sApiCoreV1EventSource, value, true) +function _decode(::Type{IoK8sApiCoreV1EventSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource"), _openapi_raw, "decoding IoK8sApiCoreV1EventSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EventSource") + _openapi_field_component = haskey(_openapi_object, "component") ? _decode(Union{Absent,Nothing,String}, _openapi_object["component"], _openapi_validate) : ABSENT + _openapi_field_host = haskey(_openapi_object, "host") ? _decode(Union{Absent,Nothing,String}, _openapi_object["host"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("component","host") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EventSource(; component = _openapi_field_component, host = _openapi_field_host, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EventSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.component isa Absent || (_openapi_output["component"] = _encode(_openapi_value.component)) + _openapi_value.host isa Absent || (_openapi_output["host"] = _encode(_openapi_value.host)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventSource"), _openapi_output, "encoding IoK8sApiCoreV1EventSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EventSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.component isa Absent || push!(_openapi_output, "component" => _openapi_value.component) + _openapi_value.host isa Absent || push!(_openapi_output, "host" => _openapi_value.host) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Event + action::Union{Absent,Nothing,String} = ABSENT + apiversion::Union{Absent,Nothing,String} = ABSENT + count::Union{Absent,Int32,Nothing} = ABSENT + eventtime::Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing} = ABSENT + firsttimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + involvedobject::IoK8sApiCoreV1ObjectReference + kind::Union{Absent,Nothing,String} = ABSENT + lasttimestamp::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::IoK8sApimachineryPkgApisMetaV1ObjectMeta + reason::Union{Absent,Nothing,String} = ABSENT + related::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + reportingcomponent::Union{Absent,Nothing,String} = ABSENT + reportinginstance::Union{Absent,Nothing,String} = ABSENT + series::Union{Absent,IoK8sApiCoreV1EventSeries,Nothing} = ABSENT + source::Union{Absent,IoK8sApiCoreV1EventSource,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Event}, value) = _decode(IoK8sApiCoreV1Event, value, true) +function _decode(::Type{IoK8sApiCoreV1Event}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Event"), _openapi_raw, "decoding IoK8sApiCoreV1Event"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Event") + _openapi_field_action = haskey(_openapi_object, "action") ? _decode(Union{Absent,Nothing,String}, _openapi_object["action"], _openapi_validate) : ABSENT + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_count = haskey(_openapi_object, "count") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["count"], _openapi_validate) : ABSENT + _openapi_field_eventtime = haskey(_openapi_object, "eventTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1MicroTime,Nothing}, _openapi_object["eventTime"], _openapi_validate) : ABSENT + _openapi_field_firsttimestamp = haskey(_openapi_object, "firstTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["firstTimestamp"], _openapi_validate) : ABSENT + _openapi_field_involvedobject = _decode(IoK8sApiCoreV1ObjectReference, _required(_openapi_object, "involvedObject", "IoK8sApiCoreV1Event"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_lasttimestamp = haskey(_openapi_object, "lastTimestamp") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTimestamp"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = _decode(IoK8sApimachineryPkgApisMetaV1ObjectMeta, _required(_openapi_object, "metadata", "IoK8sApiCoreV1Event"), _openapi_validate) + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_related = haskey(_openapi_object, "related") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["related"], _openapi_validate) : ABSENT + _openapi_field_reportingcomponent = haskey(_openapi_object, "reportingComponent") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reportingComponent"], _openapi_validate) : ABSENT + _openapi_field_reportinginstance = haskey(_openapi_object, "reportingInstance") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reportingInstance"], _openapi_validate) : ABSENT + _openapi_field_series = haskey(_openapi_object, "series") ? _decode(Union{Absent,IoK8sApiCoreV1EventSeries,Nothing}, _openapi_object["series"], _openapi_validate) : ABSENT + _openapi_field_source = haskey(_openapi_object, "source") ? _decode(Union{Absent,IoK8sApiCoreV1EventSource,Nothing}, _openapi_object["source"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("action","apiVersion","count","eventTime","firstTimestamp","involvedObject","kind","lastTimestamp","message","metadata","reason","related","reportingComponent","reportingInstance","series","source","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Event(; action = _openapi_field_action, apiversion = _openapi_field_apiversion, count = _openapi_field_count, eventtime = _openapi_field_eventtime, firsttimestamp = _openapi_field_firsttimestamp, involvedobject = _openapi_field_involvedobject, kind = _openapi_field_kind, lasttimestamp = _openapi_field_lasttimestamp, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, related = _openapi_field_related, reportingcomponent = _openapi_field_reportingcomponent, reportinginstance = _openapi_field_reportinginstance, series = _openapi_field_series, source = _openapi_field_source, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Event) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.action isa Absent || (_openapi_output["action"] = _encode(_openapi_value.action)) + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.count isa Absent || (_openapi_output["count"] = _encode(_openapi_value.count)) + _openapi_value.eventtime isa Absent || (_openapi_output["eventTime"] = _encode(_openapi_value.eventtime)) + _openapi_value.firsttimestamp isa Absent || (_openapi_output["firstTimestamp"] = _encode(_openapi_value.firsttimestamp)) + _openapi_value.involvedobject isa Absent || (_openapi_output["involvedObject"] = _encode(_openapi_value.involvedobject)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.lasttimestamp isa Absent || (_openapi_output["lastTimestamp"] = _encode(_openapi_value.lasttimestamp)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.related isa Absent || (_openapi_output["related"] = _encode(_openapi_value.related)) + _openapi_value.reportingcomponent isa Absent || (_openapi_output["reportingComponent"] = _encode(_openapi_value.reportingcomponent)) + _openapi_value.reportinginstance isa Absent || (_openapi_output["reportingInstance"] = _encode(_openapi_value.reportinginstance)) + _openapi_value.series isa Absent || (_openapi_output["series"] = _encode(_openapi_value.series)) + _openapi_value.source isa Absent || (_openapi_output["source"] = _encode(_openapi_value.source)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Event"), _openapi_output, "encoding IoK8sApiCoreV1Event"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Event) + _openapi_output = Pair{String,Any}[] + _openapi_value.action isa Absent || push!(_openapi_output, "action" => _openapi_value.action) + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.count isa Absent || push!(_openapi_output, "count" => _openapi_value.count) + _openapi_value.eventtime isa Absent || push!(_openapi_output, "eventTime" => _openapi_value.eventtime) + _openapi_value.firsttimestamp isa Absent || push!(_openapi_output, "firstTimestamp" => _openapi_value.firsttimestamp) + _openapi_value.involvedobject isa Absent || push!(_openapi_output, "involvedObject" => _openapi_value.involvedobject) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.lasttimestamp isa Absent || push!(_openapi_output, "lastTimestamp" => _openapi_value.lasttimestamp) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.related isa Absent || push!(_openapi_output, "related" => _openapi_value.related) + _openapi_value.reportingcomponent isa Absent || push!(_openapi_output, "reportingComponent" => _openapi_value.reportingcomponent) + _openapi_value.reportinginstance isa Absent || push!(_openapi_output, "reportingInstance" => _openapi_value.reportinginstance) + _openapi_value.series isa Absent || push!(_openapi_output, "series" => _openapi_value.series) + _openapi_value.source isa Absent || push!(_openapi_output, "source" => _openapi_value.source) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1EventList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Event}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1EventList}, value) = _decode(IoK8sApiCoreV1EventList, value, true) +function _decode(::Type{IoK8sApiCoreV1EventList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventList"), _openapi_raw, "decoding IoK8sApiCoreV1EventList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1EventList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Event}}, _required(_openapi_object, "items", "IoK8sApiCoreV1EventList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1EventList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1EventList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.EventList"), _openapi_output, "encoding IoK8sApiCoreV1EventList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1EventList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FCVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + lun::Union{Absent,Int32,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + targetwwns::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + wwids::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FCVolumeSource}, value) = _decode(IoK8sApiCoreV1FCVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FCVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FCVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_lun = haskey(_openapi_object, "lun") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["lun"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_targetwwns = haskey(_openapi_object, "targetWWNs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["targetWWNs"], _openapi_validate) : ABSENT + _openapi_field_wwids = haskey(_openapi_object, "wwids") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["wwids"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","lun","readOnly","targetWWNs","wwids") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FCVolumeSource(; fstype = _openapi_field_fstype, lun = _openapi_field_lun, readonly = _openapi_field_readonly, targetwwns = _openapi_field_targetwwns, wwids = _openapi_field_wwids, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.targetwwns isa Absent || (_openapi_output["targetWWNs"] = _encode(_openapi_value.targetwwns)) + _openapi_value.wwids isa Absent || (_openapi_output["wwids"] = _encode(_openapi_value.wwids)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FCVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FCVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FCVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.targetwwns isa Absent || push!(_openapi_output, "targetWWNs" => _openapi_value.targetwwns) + _openapi_value.wwids isa Absent || push!(_openapi_output, "wwids" => _openapi_value.wwids) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexPersistentVolumeSourceOptions + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSourceOptions}, value) = _decode(IoK8sApiCoreV1FlexPersistentVolumeSourceOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSourceOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource/properties/options"), _openapi_raw, "decoding IoK8sApiCoreV1FlexPersistentVolumeSourceOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexPersistentVolumeSourceOptions") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexPersistentVolumeSourceOptions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSourceOptions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource/properties/options"), _openapi_output, "encoding IoK8sApiCoreV1FlexPersistentVolumeSourceOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSourceOptions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexPersistentVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + options::Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSourceOptions,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1FlexPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlexPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexPersistentVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1FlexPersistentVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSourceOptions,Nothing}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","options","readOnly","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexPersistentVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, options = _openapi_field_options, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlexPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSourceOptions + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, value) = _decode(IoK8sApiCoreV1FlexVolumeSourceOptions, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSourceOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSourceOptions") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSourceOptions(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource/properties/options"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSourceOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSourceOptions) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlexVolumeSource + driver::String + fstype::Union{Absent,Nothing,String} = ABSENT + options::Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, value) = _decode(IoK8sApiCoreV1FlexVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlexVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlexVolumeSource") + _openapi_field_driver = _decode(String, _required(_openapi_object, "driver", "IoK8sApiCoreV1FlexVolumeSource"), _openapi_validate) + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSourceOptions,Nothing}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("driver","fsType","options","readOnly","secretRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlexVolumeSource(; driver = _openapi_field_driver, fstype = _openapi_field_fstype, options = _openapi_field_options, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.driver isa Absent || (_openapi_output["driver"] = _encode(_openapi_value.driver)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlexVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlexVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlexVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.driver isa Absent || push!(_openapi_output, "driver" => _openapi_value.driver) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1FlockerVolumeSource + datasetname::Union{Absent,Nothing,String} = ABSENT + datasetuuid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, value) = _decode(IoK8sApiCoreV1FlockerVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1FlockerVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1FlockerVolumeSource") + _openapi_field_datasetname = haskey(_openapi_object, "datasetName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetName"], _openapi_validate) : ABSENT + _openapi_field_datasetuuid = haskey(_openapi_object, "datasetUUID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["datasetUUID"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("datasetName","datasetUUID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1FlockerVolumeSource(; datasetname = _openapi_field_datasetname, datasetuuid = _openapi_field_datasetuuid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.datasetname isa Absent || (_openapi_output["datasetName"] = _encode(_openapi_value.datasetname)) + _openapi_value.datasetuuid isa Absent || (_openapi_output["datasetUUID"] = _encode(_openapi_value.datasetuuid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.FlockerVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1FlockerVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1FlockerVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.datasetname isa Absent || push!(_openapi_output, "datasetName" => _openapi_value.datasetname) + _openapi_value.datasetuuid isa Absent || push!(_openapi_output, "datasetUUID" => _openapi_value.datasetuuid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GCEPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + partition::Union{Absent,Int32,Nothing} = ABSENT + pdname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1GCEPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GCEPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GCEPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_partition = haskey(_openapi_object, "partition") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["partition"], _openapi_validate) : ABSENT + _openapi_field_pdname = _decode(String, _required(_openapi_object, "pdName", "IoK8sApiCoreV1GCEPersistentDiskVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","partition","pdName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GCEPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, partition = _openapi_field_partition, pdname = _openapi_field_pdname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.partition isa Absent || (_openapi_output["partition"] = _encode(_openapi_value.partition)) + _openapi_value.pdname isa Absent || (_openapi_output["pdName"] = _encode(_openapi_value.pdname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GCEPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GCEPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.partition isa Absent || push!(_openapi_output, "partition" => _openapi_value.partition) + _openapi_value.pdname isa Absent || push!(_openapi_output, "pdName" => _openapi_value.pdname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GitRepoVolumeSource + directory::Union{Absent,Nothing,String} = ABSENT + repository::String + revision::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, value) = _decode(IoK8sApiCoreV1GitRepoVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GitRepoVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GitRepoVolumeSource") + _openapi_field_directory = haskey(_openapi_object, "directory") ? _decode(Union{Absent,Nothing,String}, _openapi_object["directory"], _openapi_validate) : ABSENT + _openapi_field_repository = _decode(String, _required(_openapi_object, "repository", "IoK8sApiCoreV1GitRepoVolumeSource"), _openapi_validate) + _openapi_field_revision = haskey(_openapi_object, "revision") ? _decode(Union{Absent,Nothing,String}, _openapi_object["revision"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("directory","repository","revision") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GitRepoVolumeSource(; directory = _openapi_field_directory, repository = _openapi_field_repository, revision = _openapi_field_revision, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.directory isa Absent || (_openapi_output["directory"] = _encode(_openapi_value.directory)) + _openapi_value.repository isa Absent || (_openapi_output["repository"] = _encode(_openapi_value.repository)) + _openapi_value.revision isa Absent || (_openapi_output["revision"] = _encode(_openapi_value.revision)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GitRepoVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GitRepoVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GitRepoVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.directory isa Absent || push!(_openapi_output, "directory" => _openapi_value.directory) + _openapi_value.repository isa Absent || push!(_openapi_output, "repository" => _openapi_value.repository) + _openapi_value.revision isa Absent || push!(_openapi_output, "revision" => _openapi_value.revision) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GlusterfsPersistentVolumeSource + endpoints::String + endpointsnamespace::Union{Absent,Nothing,String} = ABSENT + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GlusterfsPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1GlusterfsPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GlusterfsPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GlusterfsPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GlusterfsPersistentVolumeSource") + _openapi_field_endpoints = _decode(String, _required(_openapi_object, "endpoints", "IoK8sApiCoreV1GlusterfsPersistentVolumeSource"), _openapi_validate) + _openapi_field_endpointsnamespace = haskey(_openapi_object, "endpointsNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["endpointsNamespace"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1GlusterfsPersistentVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endpoints","endpointsNamespace","path","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GlusterfsPersistentVolumeSource(; endpoints = _openapi_field_endpoints, endpointsnamespace = _openapi_field_endpointsnamespace, path = _openapi_field_path, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GlusterfsPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.endpointsnamespace isa Absent || (_openapi_output["endpointsNamespace"] = _encode(_openapi_value.endpointsnamespace)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GlusterfsPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GlusterfsPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.endpointsnamespace isa Absent || push!(_openapi_output, "endpointsNamespace" => _openapi_value.endpointsnamespace) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1GlusterfsVolumeSource + endpoints::String + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, value) = _decode(IoK8sApiCoreV1GlusterfsVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1GlusterfsVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1GlusterfsVolumeSource") + _openapi_field_endpoints = _decode(String, _required(_openapi_object, "endpoints", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1GlusterfsVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("endpoints","path","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1GlusterfsVolumeSource(; endpoints = _openapi_field_endpoints, path = _openapi_field_path, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.endpoints isa Absent || (_openapi_output["endpoints"] = _encode(_openapi_value.endpoints)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.GlusterfsVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1GlusterfsVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1GlusterfsVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.endpoints isa Absent || push!(_openapi_output, "endpoints" => _openapi_value.endpoints) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostAlias + hostnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + ip::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostAlias}, value) = _decode(IoK8sApiCoreV1HostAlias, value, true) +function _decode(::Type{IoK8sApiCoreV1HostAlias}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_raw, "decoding IoK8sApiCoreV1HostAlias"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostAlias") + _openapi_field_hostnames = haskey(_openapi_object, "hostnames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["hostnames"], _openapi_validate) : ABSENT + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1HostAlias"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostnames","ip") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostAlias(; hostnames = _openapi_field_hostnames, ip = _openapi_field_ip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostnames isa Absent || (_openapi_output["hostnames"] = _encode(_openapi_value.hostnames)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostAlias"), _openapi_output, "encoding IoK8sApiCoreV1HostAlias"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostAlias) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostnames isa Absent || push!(_openapi_output, "hostnames" => _openapi_value.hostnames) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostIP + ip::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostIP}, value) = _decode(IoK8sApiCoreV1HostIP, value, true) +function _decode(::Type{IoK8sApiCoreV1HostIP}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostIP"), _openapi_raw, "decoding IoK8sApiCoreV1HostIP"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostIP") + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1HostIP"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ip",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostIP(; ip = _openapi_field_ip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostIP) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostIP"), _openapi_output, "encoding IoK8sApiCoreV1HostIP"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostIP) + _openapi_output = Pair{String,Any}[] + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1HostPathVolumeSource + path::String + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, value) = _decode(IoK8sApiCoreV1HostPathVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1HostPathVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1HostPathVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1HostPathVolumeSource"), _openapi_validate) + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1HostPathVolumeSource(; path = _openapi_field_path, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.HostPathVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1HostPathVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1HostPathVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ISCSIPersistentVolumeSource + chapauthdiscovery::Union{Absent,Bool,Nothing} = ABSENT + chapauthsession::Union{Absent,Bool,Nothing} = ABSENT + fstype::Union{Absent,Nothing,String} = ABSENT + initiatorname::Union{Absent,Nothing,String} = ABSENT + iqn::String + iscsiinterface::Union{Absent,Nothing,String} = ABSENT + lun::Int32 + portals::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + targetportal::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ISCSIPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1ISCSIPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ISCSIPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ISCSIPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ISCSIPersistentVolumeSource") + _openapi_field_chapauthdiscovery = haskey(_openapi_object, "chapAuthDiscovery") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthDiscovery"], _openapi_validate) : ABSENT + _openapi_field_chapauthsession = haskey(_openapi_object, "chapAuthSession") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthSession"], _openapi_validate) : ABSENT + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_initiatorname = haskey(_openapi_object, "initiatorName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["initiatorName"], _openapi_validate) : ABSENT + _openapi_field_iqn = _decode(String, _required(_openapi_object, "iqn", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_iscsiinterface = haskey(_openapi_object, "iscsiInterface") ? _decode(Union{Absent,Nothing,String}, _openapi_object["iscsiInterface"], _openapi_validate) : ABSENT + _openapi_field_lun = _decode(Int32, _required(_openapi_object, "lun", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_field_portals = haskey(_openapi_object, "portals") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["portals"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_targetportal = _decode(String, _required(_openapi_object, "targetPortal", "IoK8sApiCoreV1ISCSIPersistentVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("chapAuthDiscovery","chapAuthSession","fsType","initiatorName","iqn","iscsiInterface","lun","portals","readOnly","secretRef","targetPortal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ISCSIPersistentVolumeSource(; chapauthdiscovery = _openapi_field_chapauthdiscovery, chapauthsession = _openapi_field_chapauthsession, fstype = _openapi_field_fstype, initiatorname = _openapi_field_initiatorname, iqn = _openapi_field_iqn, iscsiinterface = _openapi_field_iscsiinterface, lun = _openapi_field_lun, portals = _openapi_field_portals, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, targetportal = _openapi_field_targetportal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ISCSIPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.chapauthdiscovery isa Absent || (_openapi_output["chapAuthDiscovery"] = _encode(_openapi_value.chapauthdiscovery)) + _openapi_value.chapauthsession isa Absent || (_openapi_output["chapAuthSession"] = _encode(_openapi_value.chapauthsession)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.initiatorname isa Absent || (_openapi_output["initiatorName"] = _encode(_openapi_value.initiatorname)) + _openapi_value.iqn isa Absent || (_openapi_output["iqn"] = _encode(_openapi_value.iqn)) + _openapi_value.iscsiinterface isa Absent || (_openapi_output["iscsiInterface"] = _encode(_openapi_value.iscsiinterface)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.portals isa Absent || (_openapi_output["portals"] = _encode(_openapi_value.portals)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.targetportal isa Absent || (_openapi_output["targetPortal"] = _encode(_openapi_value.targetportal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ISCSIPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ISCSIPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.chapauthdiscovery isa Absent || push!(_openapi_output, "chapAuthDiscovery" => _openapi_value.chapauthdiscovery) + _openapi_value.chapauthsession isa Absent || push!(_openapi_output, "chapAuthSession" => _openapi_value.chapauthsession) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.initiatorname isa Absent || push!(_openapi_output, "initiatorName" => _openapi_value.initiatorname) + _openapi_value.iqn isa Absent || push!(_openapi_output, "iqn" => _openapi_value.iqn) + _openapi_value.iscsiinterface isa Absent || push!(_openapi_output, "iscsiInterface" => _openapi_value.iscsiinterface) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.portals isa Absent || push!(_openapi_output, "portals" => _openapi_value.portals) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.targetportal isa Absent || push!(_openapi_output, "targetPortal" => _openapi_value.targetportal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ISCSIVolumeSource + chapauthdiscovery::Union{Absent,Bool,Nothing} = ABSENT + chapauthsession::Union{Absent,Bool,Nothing} = ABSENT + fstype::Union{Absent,Nothing,String} = ABSENT + initiatorname::Union{Absent,Nothing,String} = ABSENT + iqn::String + iscsiinterface::Union{Absent,Nothing,String} = ABSENT + lun::Int32 + portals::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + targetportal::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, value) = _decode(IoK8sApiCoreV1ISCSIVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ISCSIVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ISCSIVolumeSource") + _openapi_field_chapauthdiscovery = haskey(_openapi_object, "chapAuthDiscovery") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthDiscovery"], _openapi_validate) : ABSENT + _openapi_field_chapauthsession = haskey(_openapi_object, "chapAuthSession") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["chapAuthSession"], _openapi_validate) : ABSENT + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_initiatorname = haskey(_openapi_object, "initiatorName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["initiatorName"], _openapi_validate) : ABSENT + _openapi_field_iqn = _decode(String, _required(_openapi_object, "iqn", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_iscsiinterface = haskey(_openapi_object, "iscsiInterface") ? _decode(Union{Absent,Nothing,String}, _openapi_object["iscsiInterface"], _openapi_validate) : ABSENT + _openapi_field_lun = _decode(Int32, _required(_openapi_object, "lun", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_field_portals = haskey(_openapi_object, "portals") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["portals"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_targetportal = _decode(String, _required(_openapi_object, "targetPortal", "IoK8sApiCoreV1ISCSIVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("chapAuthDiscovery","chapAuthSession","fsType","initiatorName","iqn","iscsiInterface","lun","portals","readOnly","secretRef","targetPortal") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ISCSIVolumeSource(; chapauthdiscovery = _openapi_field_chapauthdiscovery, chapauthsession = _openapi_field_chapauthsession, fstype = _openapi_field_fstype, initiatorname = _openapi_field_initiatorname, iqn = _openapi_field_iqn, iscsiinterface = _openapi_field_iscsiinterface, lun = _openapi_field_lun, portals = _openapi_field_portals, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, targetportal = _openapi_field_targetportal, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.chapauthdiscovery isa Absent || (_openapi_output["chapAuthDiscovery"] = _encode(_openapi_value.chapauthdiscovery)) + _openapi_value.chapauthsession isa Absent || (_openapi_output["chapAuthSession"] = _encode(_openapi_value.chapauthsession)) + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.initiatorname isa Absent || (_openapi_output["initiatorName"] = _encode(_openapi_value.initiatorname)) + _openapi_value.iqn isa Absent || (_openapi_output["iqn"] = _encode(_openapi_value.iqn)) + _openapi_value.iscsiinterface isa Absent || (_openapi_output["iscsiInterface"] = _encode(_openapi_value.iscsiinterface)) + _openapi_value.lun isa Absent || (_openapi_output["lun"] = _encode(_openapi_value.lun)) + _openapi_value.portals isa Absent || (_openapi_output["portals"] = _encode(_openapi_value.portals)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.targetportal isa Absent || (_openapi_output["targetPortal"] = _encode(_openapi_value.targetportal)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ISCSIVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ISCSIVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ISCSIVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.chapauthdiscovery isa Absent || push!(_openapi_output, "chapAuthDiscovery" => _openapi_value.chapauthdiscovery) + _openapi_value.chapauthsession isa Absent || push!(_openapi_output, "chapAuthSession" => _openapi_value.chapauthsession) + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.initiatorname isa Absent || push!(_openapi_output, "initiatorName" => _openapi_value.initiatorname) + _openapi_value.iqn isa Absent || push!(_openapi_output, "iqn" => _openapi_value.iqn) + _openapi_value.iscsiinterface isa Absent || push!(_openapi_output, "iscsiInterface" => _openapi_value.iscsiinterface) + _openapi_value.lun isa Absent || push!(_openapi_output, "lun" => _openapi_value.lun) + _openapi_value.portals isa Absent || push!(_openapi_output, "portals" => _openapi_value.portals) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.targetportal isa Absent || push!(_openapi_output, "targetPortal" => _openapi_value.targetportal) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ImageVolumeSource + pullpolicy::Union{Absent,Nothing,String} = ABSENT + reference::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, value) = _decode(IoK8sApiCoreV1ImageVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ImageVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ImageVolumeSource") + _openapi_field_pullpolicy = haskey(_openapi_object, "pullPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pullPolicy"], _openapi_validate) : ABSENT + _openapi_field_reference = haskey(_openapi_object, "reference") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reference"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("pullPolicy","reference") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ImageVolumeSource(; pullpolicy = _openapi_field_pullpolicy, reference = _openapi_field_reference, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.pullpolicy isa Absent || (_openapi_output["pullPolicy"] = _encode(_openapi_value.pullpolicy)) + _openapi_value.reference isa Absent || (_openapi_output["reference"] = _encode(_openapi_value.reference)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ImageVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ImageVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ImageVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.pullpolicy isa Absent || push!(_openapi_output, "pullPolicy" => _openapi_value.pullpolicy) + _openapi_value.reference isa Absent || push!(_openapi_output, "reference" => _openapi_value.reference) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItemDefault + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItemDefault}, value) = _decode(IoK8sApiCoreV1LimitRangeItemDefault, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItemDefault}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/default"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItemDefault"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItemDefault") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItemDefault(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItemDefault) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/default"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItemDefault"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItemDefault) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItemDefaultRequest + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItemDefaultRequest}, value) = _decode(IoK8sApiCoreV1LimitRangeItemDefaultRequest, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItemDefaultRequest}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/defaultRequest"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItemDefaultRequest"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItemDefaultRequest") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItemDefaultRequest(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItemDefaultRequest) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/defaultRequest"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItemDefaultRequest"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItemDefaultRequest) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItemMax + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItemMax}, value) = _decode(IoK8sApiCoreV1LimitRangeItemMax, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItemMax}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/max"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItemMax"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItemMax") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItemMax(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItemMax) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/max"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItemMax"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItemMax) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio}, value) = _decode(IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/maxLimitRequestRatio"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/maxLimitRequestRatio"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItemMin + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItemMin}, value) = _decode(IoK8sApiCoreV1LimitRangeItemMin, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItemMin}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/min"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItemMin"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItemMin") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItemMin(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItemMin) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem/properties/min"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItemMin"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItemMin) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeItem + default::Union{Absent,IoK8sApiCoreV1LimitRangeItemDefault,Nothing} = ABSENT + defaultrequest::Union{Absent,IoK8sApiCoreV1LimitRangeItemDefaultRequest,Nothing} = ABSENT + max::Union{Absent,IoK8sApiCoreV1LimitRangeItemMax,Nothing} = ABSENT + maxlimitrequestratio::Union{Absent,IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio,Nothing} = ABSENT + min::Union{Absent,IoK8sApiCoreV1LimitRangeItemMin,Nothing} = ABSENT + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeItem}, value) = _decode(IoK8sApiCoreV1LimitRangeItem, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeItem") + _openapi_field_default = haskey(_openapi_object, "default") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeItemDefault,Nothing}, _openapi_object["default"], _openapi_validate) : ABSENT + _openapi_field_defaultrequest = haskey(_openapi_object, "defaultRequest") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeItemDefaultRequest,Nothing}, _openapi_object["defaultRequest"], _openapi_validate) : ABSENT + _openapi_field_max = haskey(_openapi_object, "max") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeItemMax,Nothing}, _openapi_object["max"], _openapi_validate) : ABSENT + _openapi_field_maxlimitrequestratio = haskey(_openapi_object, "maxLimitRequestRatio") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeItemMaxLimitRequestRatio,Nothing}, _openapi_object["maxLimitRequestRatio"], _openapi_validate) : ABSENT + _openapi_field_min = haskey(_openapi_object, "min") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeItemMin,Nothing}, _openapi_object["min"], _openapi_validate) : ABSENT + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1LimitRangeItem"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("default","defaultRequest","max","maxLimitRequestRatio","min","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeItem(; default = _openapi_field_default, defaultrequest = _openapi_field_defaultrequest, max = _openapi_field_max, maxlimitrequestratio = _openapi_field_maxlimitrequestratio, min = _openapi_field_min, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeItem) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.default isa Absent || (_openapi_output["default"] = _encode(_openapi_value.default)) + _openapi_value.defaultrequest isa Absent || (_openapi_output["defaultRequest"] = _encode(_openapi_value.defaultrequest)) + _openapi_value.max isa Absent || (_openapi_output["max"] = _encode(_openapi_value.max)) + _openapi_value.maxlimitrequestratio isa Absent || (_openapi_output["maxLimitRequestRatio"] = _encode(_openapi_value.maxlimitrequestratio)) + _openapi_value.min isa Absent || (_openapi_output["min"] = _encode(_openapi_value.min)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeItem"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeItem) + _openapi_output = Pair{String,Any}[] + _openapi_value.default isa Absent || push!(_openapi_output, "default" => _openapi_value.default) + _openapi_value.defaultrequest isa Absent || push!(_openapi_output, "defaultRequest" => _openapi_value.defaultrequest) + _openapi_value.max isa Absent || push!(_openapi_output, "max" => _openapi_value.max) + _openapi_value.maxlimitrequestratio isa Absent || push!(_openapi_output, "maxLimitRequestRatio" => _openapi_value.maxlimitrequestratio) + _openapi_value.min isa Absent || push!(_openapi_output, "min" => _openapi_value.min) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeSpec + limits::Union{Nothing,Vector{IoK8sApiCoreV1LimitRangeItem}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeSpec}, value) = _decode(IoK8sApiCoreV1LimitRangeSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeSpec"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeSpec") + _openapi_field_limits = _decode(Union{Nothing,Vector{IoK8sApiCoreV1LimitRangeItem}}, _required(_openapi_object, "limits", "IoK8sApiCoreV1LimitRangeSpec"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("limits",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeSpec(; limits = _openapi_field_limits, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.limits isa Absent || (_openapi_output["limits"] = _encode(_openapi_value.limits)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeSpec"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.limits isa Absent || push!(_openapi_output, "limits" => _openapi_value.limits) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRange + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1LimitRangeSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LimitRange}, value) = _decode(IoK8sApiCoreV1LimitRange, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRange}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRange"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRange"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRange") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1LimitRangeSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRange(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRange) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRange"), _openapi_output, "encoding IoK8sApiCoreV1LimitRange"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRange) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LimitRangeList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1LimitRange}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LimitRangeList}, value) = _decode(IoK8sApiCoreV1LimitRangeList, value, true) +function _decode(::Type{IoK8sApiCoreV1LimitRangeList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeList"), _openapi_raw, "decoding IoK8sApiCoreV1LimitRangeList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LimitRangeList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1LimitRange}}, _required(_openapi_object, "items", "IoK8sApiCoreV1LimitRangeList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LimitRangeList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LimitRangeList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LimitRangeList"), _openapi_output, "encoding IoK8sApiCoreV1LimitRangeList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LimitRangeList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PortStatus + error::Union{Absent,Nothing,String} = ABSENT + port::Int32 + protocol::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PortStatus}, value) = _decode(IoK8sApiCoreV1PortStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PortStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PortStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PortStatus") + _openapi_field_error = haskey(_openapi_object, "error") ? _decode(Union{Absent,Nothing,String}, _openapi_object["error"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1PortStatus"), _openapi_validate) + _openapi_field_protocol = _decode(String, _required(_openapi_object, "protocol", "IoK8sApiCoreV1PortStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("error","port","protocol") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PortStatus(; error = _openapi_field_error, port = _openapi_field_port, protocol = _openapi_field_protocol, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PortStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.error isa Absent || (_openapi_output["error"] = _encode(_openapi_value.error)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortStatus"), _openapi_output, "encoding IoK8sApiCoreV1PortStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PortStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.error isa Absent || push!(_openapi_output, "error" => _openapi_value.error) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LoadBalancerIngress + hostname::Union{Absent,Nothing,String} = ABSENT + ip::Union{Absent,Nothing,String} = ABSENT + ipmode::Union{Absent,Nothing,String} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PortStatus}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LoadBalancerIngress}, value) = _decode(IoK8sApiCoreV1LoadBalancerIngress, value, true) +function _decode(::Type{IoK8sApiCoreV1LoadBalancerIngress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress"), _openapi_raw, "decoding IoK8sApiCoreV1LoadBalancerIngress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LoadBalancerIngress") + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_ip = haskey(_openapi_object, "ip") ? _decode(Union{Absent,Nothing,String}, _openapi_object["ip"], _openapi_validate) : ABSENT + _openapi_field_ipmode = haskey(_openapi_object, "ipMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["ipMode"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PortStatus}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hostname","ip","ipMode","ports") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LoadBalancerIngress(; hostname = _openapi_field_hostname, ip = _openapi_field_ip, ipmode = _openapi_field_ipmode, ports = _openapi_field_ports, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LoadBalancerIngress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + _openapi_value.ipmode isa Absent || (_openapi_output["ipMode"] = _encode(_openapi_value.ipmode)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerIngress"), _openapi_output, "encoding IoK8sApiCoreV1LoadBalancerIngress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LoadBalancerIngress) + _openapi_output = Pair{String,Any}[] + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + _openapi_value.ipmode isa Absent || push!(_openapi_output, "ipMode" => _openapi_value.ipmode) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LoadBalancerStatus + ingress::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LoadBalancerIngress}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LoadBalancerStatus}, value) = _decode(IoK8sApiCoreV1LoadBalancerStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1LoadBalancerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus"), _openapi_raw, "decoding IoK8sApiCoreV1LoadBalancerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LoadBalancerStatus") + _openapi_field_ingress = haskey(_openapi_object, "ingress") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LoadBalancerIngress}}}, _openapi_object["ingress"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ingress",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LoadBalancerStatus(; ingress = _openapi_field_ingress, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LoadBalancerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ingress isa Absent || (_openapi_output["ingress"] = _encode(_openapi_value.ingress)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LoadBalancerStatus"), _openapi_output, "encoding IoK8sApiCoreV1LoadBalancerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LoadBalancerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.ingress isa Absent || push!(_openapi_output, "ingress" => _openapi_value.ingress) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1LocalVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1LocalVolumeSource}, value) = _decode(IoK8sApiCoreV1LocalVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1LocalVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1LocalVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1LocalVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1LocalVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1LocalVolumeSource(; fstype = _openapi_field_fstype, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1LocalVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.LocalVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1LocalVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1LocalVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ModifyVolumeStatus + status::String + targetvolumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ModifyVolumeStatus}, value) = _decode(IoK8sApiCoreV1ModifyVolumeStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ModifyVolumeStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ModifyVolumeStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ModifyVolumeStatus") + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1ModifyVolumeStatus"), _openapi_validate) + _openapi_field_targetvolumeattributesclassname = haskey(_openapi_object, "targetVolumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["targetVolumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("status","targetVolumeAttributesClassName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ModifyVolumeStatus(; status = _openapi_field_status, targetvolumeattributesclassname = _openapi_field_targetvolumeattributesclassname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ModifyVolumeStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.targetvolumeattributesclassname isa Absent || (_openapi_output["targetVolumeAttributesClassName"] = _encode(_openapi_value.targetvolumeattributesclassname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ModifyVolumeStatus"), _openapi_output, "encoding IoK8sApiCoreV1ModifyVolumeStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ModifyVolumeStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.targetvolumeattributesclassname isa Absent || push!(_openapi_output, "targetVolumeAttributesClassName" => _openapi_value.targetvolumeattributesclassname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NFSVolumeSource + path::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + server::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, value) = _decode(IoK8sApiCoreV1NFSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1NFSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NFSVolumeSource") + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_server = _decode(String, _required(_openapi_object, "server", "IoK8sApiCoreV1NFSVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("path","readOnly","server") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NFSVolumeSource(; path = _openapi_field_path, readonly = _openapi_field_readonly, server = _openapi_field_server, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.server isa Absent || (_openapi_output["server"] = _encode(_openapi_value.server)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NFSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1NFSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NFSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.server isa Absent || push!(_openapi_output, "server" => _openapi_value.server) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NamespaceSpec + finalizers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NamespaceSpec}, value) = _decode(IoK8sApiCoreV1NamespaceSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1NamespaceSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceSpec"), _openapi_raw, "decoding IoK8sApiCoreV1NamespaceSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NamespaceSpec") + _openapi_field_finalizers = haskey(_openapi_object, "finalizers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["finalizers"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("finalizers",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NamespaceSpec(; finalizers = _openapi_field_finalizers, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NamespaceSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.finalizers isa Absent || (_openapi_output["finalizers"] = _encode(_openapi_value.finalizers)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceSpec"), _openapi_output, "encoding IoK8sApiCoreV1NamespaceSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NamespaceSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.finalizers isa Absent || push!(_openapi_output, "finalizers" => _openapi_value.finalizers) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NamespaceCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NamespaceCondition}, value) = _decode(IoK8sApiCoreV1NamespaceCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1NamespaceCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceCondition"), _openapi_raw, "decoding IoK8sApiCoreV1NamespaceCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NamespaceCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1NamespaceCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1NamespaceCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NamespaceCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NamespaceCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceCondition"), _openapi_output, "encoding IoK8sApiCoreV1NamespaceCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NamespaceCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NamespaceStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NamespaceCondition}}} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NamespaceStatus}, value) = _decode(IoK8sApiCoreV1NamespaceStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1NamespaceStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceStatus"), _openapi_raw, "decoding IoK8sApiCoreV1NamespaceStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NamespaceStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NamespaceCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions","phase") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NamespaceStatus(; conditions = _openapi_field_conditions, phase = _openapi_field_phase, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NamespaceStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceStatus"), _openapi_output, "encoding IoK8sApiCoreV1NamespaceStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NamespaceStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Namespace + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1NamespaceSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1NamespaceStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Namespace}, value) = _decode(IoK8sApiCoreV1Namespace, value, true) +function _decode(::Type{IoK8sApiCoreV1Namespace}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Namespace"), _openapi_raw, "decoding IoK8sApiCoreV1Namespace"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Namespace") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1NamespaceSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1NamespaceStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Namespace(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Namespace) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Namespace"), _openapi_output, "encoding IoK8sApiCoreV1Namespace"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Namespace) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NamespaceList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Namespace}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NamespaceList}, value) = _decode(IoK8sApiCoreV1NamespaceList, value, true) +function _decode(::Type{IoK8sApiCoreV1NamespaceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceList"), _openapi_raw, "decoding IoK8sApiCoreV1NamespaceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NamespaceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Namespace}}, _required(_openapi_object, "items", "IoK8sApiCoreV1NamespaceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NamespaceList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NamespaceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NamespaceList"), _openapi_output, "encoding IoK8sApiCoreV1NamespaceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NamespaceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeConfigSource + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapNodeConfigSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeConfigSource}, value) = _decode(IoK8sApiCoreV1NodeConfigSource, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeConfigSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigSource"), _openapi_raw, "decoding IoK8sApiCoreV1NodeConfigSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeConfigSource") + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapNodeConfigSource,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configMap",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeConfigSource(; configmap = _openapi_field_configmap, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeConfigSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigSource"), _openapi_output, "encoding IoK8sApiCoreV1NodeConfigSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeConfigSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Taint + effect::String + key::String + timeadded::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Taint}, value) = _decode(IoK8sApiCoreV1Taint, value, true) +function _decode(::Type{IoK8sApiCoreV1Taint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Taint"), _openapi_raw, "decoding IoK8sApiCoreV1Taint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Taint") + _openapi_field_effect = _decode(String, _required(_openapi_object, "effect", "IoK8sApiCoreV1Taint"), _openapi_validate) + _openapi_field_key = _decode(String, _required(_openapi_object, "key", "IoK8sApiCoreV1Taint"), _openapi_validate) + _openapi_field_timeadded = haskey(_openapi_object, "timeAdded") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["timeAdded"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("effect","key","timeAdded","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Taint(; effect = _openapi_field_effect, key = _openapi_field_key, timeadded = _openapi_field_timeadded, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Taint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.effect isa Absent || (_openapi_output["effect"] = _encode(_openapi_value.effect)) + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.timeadded isa Absent || (_openapi_output["timeAdded"] = _encode(_openapi_value.timeadded)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Taint"), _openapi_output, "encoding IoK8sApiCoreV1Taint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Taint) + _openapi_output = Pair{String,Any}[] + _openapi_value.effect isa Absent || push!(_openapi_output, "effect" => _openapi_value.effect) + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.timeadded isa Absent || push!(_openapi_output, "timeAdded" => _openapi_value.timeadded) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSpec + configsource::Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing} = ABSENT + externalid::Union{Absent,Nothing,String} = ABSENT + podcidr::Union{Absent,Nothing,String} = ABSENT + podcidrs::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + providerid::Union{Absent,Nothing,String} = ABSENT + taints::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Taint}}} = ABSENT + unschedulable::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSpec}, value) = _decode(IoK8sApiCoreV1NodeSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSpec"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSpec") + _openapi_field_configsource = haskey(_openapi_object, "configSource") ? _decode(Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing}, _openapi_object["configSource"], _openapi_validate) : ABSENT + _openapi_field_externalid = haskey(_openapi_object, "externalID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["externalID"], _openapi_validate) : ABSENT + _openapi_field_podcidr = haskey(_openapi_object, "podCIDR") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podCIDR"], _openapi_validate) : ABSENT + _openapi_field_podcidrs = haskey(_openapi_object, "podCIDRs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["podCIDRs"], _openapi_validate) : ABSENT + _openapi_field_providerid = haskey(_openapi_object, "providerID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["providerID"], _openapi_validate) : ABSENT + _openapi_field_taints = haskey(_openapi_object, "taints") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Taint}}}, _openapi_object["taints"], _openapi_validate) : ABSENT + _openapi_field_unschedulable = haskey(_openapi_object, "unschedulable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["unschedulable"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("configSource","externalID","podCIDR","podCIDRs","providerID","taints","unschedulable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSpec(; configsource = _openapi_field_configsource, externalid = _openapi_field_externalid, podcidr = _openapi_field_podcidr, podcidrs = _openapi_field_podcidrs, providerid = _openapi_field_providerid, taints = _openapi_field_taints, unschedulable = _openapi_field_unschedulable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.configsource isa Absent || (_openapi_output["configSource"] = _encode(_openapi_value.configsource)) + _openapi_value.externalid isa Absent || (_openapi_output["externalID"] = _encode(_openapi_value.externalid)) + _openapi_value.podcidr isa Absent || (_openapi_output["podCIDR"] = _encode(_openapi_value.podcidr)) + _openapi_value.podcidrs isa Absent || (_openapi_output["podCIDRs"] = _encode(_openapi_value.podcidrs)) + _openapi_value.providerid isa Absent || (_openapi_output["providerID"] = _encode(_openapi_value.providerid)) + _openapi_value.taints isa Absent || (_openapi_output["taints"] = _encode(_openapi_value.taints)) + _openapi_value.unschedulable isa Absent || (_openapi_output["unschedulable"] = _encode(_openapi_value.unschedulable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSpec"), _openapi_output, "encoding IoK8sApiCoreV1NodeSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.configsource isa Absent || push!(_openapi_output, "configSource" => _openapi_value.configsource) + _openapi_value.externalid isa Absent || push!(_openapi_output, "externalID" => _openapi_value.externalid) + _openapi_value.podcidr isa Absent || push!(_openapi_output, "podCIDR" => _openapi_value.podcidr) + _openapi_value.podcidrs isa Absent || push!(_openapi_output, "podCIDRs" => _openapi_value.podcidrs) + _openapi_value.providerid isa Absent || push!(_openapi_output, "providerID" => _openapi_value.providerid) + _openapi_value.taints isa Absent || push!(_openapi_output, "taints" => _openapi_value.taints) + _openapi_value.unschedulable isa Absent || push!(_openapi_output, "unschedulable" => _openapi_value.unschedulable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeAddress + address::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeAddress}, value) = _decode(IoK8sApiCoreV1NodeAddress, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeAddress}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAddress"), _openapi_raw, "decoding IoK8sApiCoreV1NodeAddress"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeAddress") + _openapi_field_address = _decode(String, _required(_openapi_object, "address", "IoK8sApiCoreV1NodeAddress"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1NodeAddress"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("address","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeAddress(; address = _openapi_field_address, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeAddress) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.address isa Absent || (_openapi_output["address"] = _encode(_openapi_value.address)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeAddress"), _openapi_output, "encoding IoK8sApiCoreV1NodeAddress"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeAddress) + _openapi_output = Pair{String,Any}[] + _openapi_value.address isa Absent || push!(_openapi_output, "address" => _openapi_value.address) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeStatusAllocatable + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1NodeStatusAllocatable}, value) = _decode(IoK8sApiCoreV1NodeStatusAllocatable, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeStatusAllocatable}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus/properties/allocatable"), _openapi_raw, "decoding IoK8sApiCoreV1NodeStatusAllocatable"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeStatusAllocatable") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeStatusAllocatable(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeStatusAllocatable) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus/properties/allocatable"), _openapi_output, "encoding IoK8sApiCoreV1NodeStatusAllocatable"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeStatusAllocatable) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeStatusCapacity + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1NodeStatusCapacity}, value) = _decode(IoK8sApiCoreV1NodeStatusCapacity, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeStatusCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus/properties/capacity"), _openapi_raw, "decoding IoK8sApiCoreV1NodeStatusCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeStatusCapacity") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeStatusCapacity(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeStatusCapacity) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus/properties/capacity"), _openapi_output, "encoding IoK8sApiCoreV1NodeStatusCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeStatusCapacity) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeCondition + lastheartbeattime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeCondition}, value) = _decode(IoK8sApiCoreV1NodeCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeCondition"), _openapi_raw, "decoding IoK8sApiCoreV1NodeCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeCondition") + _openapi_field_lastheartbeattime = haskey(_openapi_object, "lastHeartbeatTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastHeartbeatTime"], _openapi_validate) : ABSENT + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1NodeCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1NodeCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastHeartbeatTime","lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeCondition(; lastheartbeattime = _openapi_field_lastheartbeattime, lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastheartbeattime isa Absent || (_openapi_output["lastHeartbeatTime"] = _encode(_openapi_value.lastheartbeattime)) + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeCondition"), _openapi_output, "encoding IoK8sApiCoreV1NodeCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastheartbeattime isa Absent || push!(_openapi_output, "lastHeartbeatTime" => _openapi_value.lastheartbeattime) + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeConfigStatus + active::Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing} = ABSENT + assigned::Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing} = ABSENT + error::Union{Absent,Nothing,String} = ABSENT + lastknowngood::Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeConfigStatus}, value) = _decode(IoK8sApiCoreV1NodeConfigStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeConfigStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigStatus"), _openapi_raw, "decoding IoK8sApiCoreV1NodeConfigStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeConfigStatus") + _openapi_field_active = haskey(_openapi_object, "active") ? _decode(Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing}, _openapi_object["active"], _openapi_validate) : ABSENT + _openapi_field_assigned = haskey(_openapi_object, "assigned") ? _decode(Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing}, _openapi_object["assigned"], _openapi_validate) : ABSENT + _openapi_field_error = haskey(_openapi_object, "error") ? _decode(Union{Absent,Nothing,String}, _openapi_object["error"], _openapi_validate) : ABSENT + _openapi_field_lastknowngood = haskey(_openapi_object, "lastKnownGood") ? _decode(Union{Absent,IoK8sApiCoreV1NodeConfigSource,Nothing}, _openapi_object["lastKnownGood"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("active","assigned","error","lastKnownGood") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeConfigStatus(; active = _openapi_field_active, assigned = _openapi_field_assigned, error = _openapi_field_error, lastknowngood = _openapi_field_lastknowngood, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeConfigStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.active isa Absent || (_openapi_output["active"] = _encode(_openapi_value.active)) + _openapi_value.assigned isa Absent || (_openapi_output["assigned"] = _encode(_openapi_value.assigned)) + _openapi_value.error isa Absent || (_openapi_output["error"] = _encode(_openapi_value.error)) + _openapi_value.lastknowngood isa Absent || (_openapi_output["lastKnownGood"] = _encode(_openapi_value.lastknowngood)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeConfigStatus"), _openapi_output, "encoding IoK8sApiCoreV1NodeConfigStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeConfigStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.active isa Absent || push!(_openapi_output, "active" => _openapi_value.active) + _openapi_value.assigned isa Absent || push!(_openapi_output, "assigned" => _openapi_value.assigned) + _openapi_value.error isa Absent || push!(_openapi_output, "error" => _openapi_value.error) + _openapi_value.lastknowngood isa Absent || push!(_openapi_output, "lastKnownGood" => _openapi_value.lastknowngood) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeDaemonEndpoints + kubeletendpoint::Union{Absent,IoK8sApiCoreV1DaemonEndpoint,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeDaemonEndpoints}, value) = _decode(IoK8sApiCoreV1NodeDaemonEndpoints, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeDaemonEndpoints}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints"), _openapi_raw, "decoding IoK8sApiCoreV1NodeDaemonEndpoints"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeDaemonEndpoints") + _openapi_field_kubeletendpoint = haskey(_openapi_object, "kubeletEndpoint") ? _decode(Union{Absent,IoK8sApiCoreV1DaemonEndpoint,Nothing}, _openapi_object["kubeletEndpoint"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("kubeletEndpoint",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeDaemonEndpoints(; kubeletendpoint = _openapi_field_kubeletendpoint, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeDaemonEndpoints) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.kubeletendpoint isa Absent || (_openapi_output["kubeletEndpoint"] = _encode(_openapi_value.kubeletendpoint)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeDaemonEndpoints"), _openapi_output, "encoding IoK8sApiCoreV1NodeDaemonEndpoints"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeDaemonEndpoints) + _openapi_output = Pair{String,Any}[] + _openapi_value.kubeletendpoint isa Absent || push!(_openapi_output, "kubeletEndpoint" => _openapi_value.kubeletendpoint) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeFeatures + supplementalgroupspolicy::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeFeatures}, value) = _decode(IoK8sApiCoreV1NodeFeatures, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeFeatures}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeFeatures"), _openapi_raw, "decoding IoK8sApiCoreV1NodeFeatures"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeFeatures") + _openapi_field_supplementalgroupspolicy = haskey(_openapi_object, "supplementalGroupsPolicy") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["supplementalGroupsPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("supplementalGroupsPolicy",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeFeatures(; supplementalgroupspolicy = _openapi_field_supplementalgroupspolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeFeatures) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.supplementalgroupspolicy isa Absent || (_openapi_output["supplementalGroupsPolicy"] = _encode(_openapi_value.supplementalgroupspolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeFeatures"), _openapi_output, "encoding IoK8sApiCoreV1NodeFeatures"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeFeatures) + _openapi_output = Pair{String,Any}[] + _openapi_value.supplementalgroupspolicy isa Absent || push!(_openapi_output, "supplementalGroupsPolicy" => _openapi_value.supplementalgroupspolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSwapStatus + capacity::Union{Absent,Int64,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSwapStatus}, value) = _decode(IoK8sApiCoreV1NodeSwapStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSwapStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSwapStatus"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSwapStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSwapStatus") + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("capacity",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSwapStatus(; capacity = _openapi_field_capacity, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSwapStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSwapStatus"), _openapi_output, "encoding IoK8sApiCoreV1NodeSwapStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSwapStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeSystemInfo + architecture::String + bootid::String + containerruntimeversion::String + kernelversion::String + kubeproxyversion::String + kubeletversion::String + machineid::String + operatingsystem::String + osimage::String + swap::Union{Absent,IoK8sApiCoreV1NodeSwapStatus,Nothing} = ABSENT + systemuuid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeSystemInfo}, value) = _decode(IoK8sApiCoreV1NodeSystemInfo, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeSystemInfo}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSystemInfo"), _openapi_raw, "decoding IoK8sApiCoreV1NodeSystemInfo"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeSystemInfo") + _openapi_field_architecture = _decode(String, _required(_openapi_object, "architecture", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_bootid = _decode(String, _required(_openapi_object, "bootID", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_containerruntimeversion = _decode(String, _required(_openapi_object, "containerRuntimeVersion", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_kernelversion = _decode(String, _required(_openapi_object, "kernelVersion", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_kubeproxyversion = _decode(String, _required(_openapi_object, "kubeProxyVersion", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_kubeletversion = _decode(String, _required(_openapi_object, "kubeletVersion", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_machineid = _decode(String, _required(_openapi_object, "machineID", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_operatingsystem = _decode(String, _required(_openapi_object, "operatingSystem", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_osimage = _decode(String, _required(_openapi_object, "osImage", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_field_swap = haskey(_openapi_object, "swap") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSwapStatus,Nothing}, _openapi_object["swap"], _openapi_validate) : ABSENT + _openapi_field_systemuuid = _decode(String, _required(_openapi_object, "systemUUID", "IoK8sApiCoreV1NodeSystemInfo"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("architecture","bootID","containerRuntimeVersion","kernelVersion","kubeProxyVersion","kubeletVersion","machineID","operatingSystem","osImage","swap","systemUUID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeSystemInfo(; architecture = _openapi_field_architecture, bootid = _openapi_field_bootid, containerruntimeversion = _openapi_field_containerruntimeversion, kernelversion = _openapi_field_kernelversion, kubeproxyversion = _openapi_field_kubeproxyversion, kubeletversion = _openapi_field_kubeletversion, machineid = _openapi_field_machineid, operatingsystem = _openapi_field_operatingsystem, osimage = _openapi_field_osimage, swap = _openapi_field_swap, systemuuid = _openapi_field_systemuuid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeSystemInfo) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.architecture isa Absent || (_openapi_output["architecture"] = _encode(_openapi_value.architecture)) + _openapi_value.bootid isa Absent || (_openapi_output["bootID"] = _encode(_openapi_value.bootid)) + _openapi_value.containerruntimeversion isa Absent || (_openapi_output["containerRuntimeVersion"] = _encode(_openapi_value.containerruntimeversion)) + _openapi_value.kernelversion isa Absent || (_openapi_output["kernelVersion"] = _encode(_openapi_value.kernelversion)) + _openapi_value.kubeproxyversion isa Absent || (_openapi_output["kubeProxyVersion"] = _encode(_openapi_value.kubeproxyversion)) + _openapi_value.kubeletversion isa Absent || (_openapi_output["kubeletVersion"] = _encode(_openapi_value.kubeletversion)) + _openapi_value.machineid isa Absent || (_openapi_output["machineID"] = _encode(_openapi_value.machineid)) + _openapi_value.operatingsystem isa Absent || (_openapi_output["operatingSystem"] = _encode(_openapi_value.operatingsystem)) + _openapi_value.osimage isa Absent || (_openapi_output["osImage"] = _encode(_openapi_value.osimage)) + _openapi_value.swap isa Absent || (_openapi_output["swap"] = _encode(_openapi_value.swap)) + _openapi_value.systemuuid isa Absent || (_openapi_output["systemUUID"] = _encode(_openapi_value.systemuuid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeSystemInfo"), _openapi_output, "encoding IoK8sApiCoreV1NodeSystemInfo"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeSystemInfo) + _openapi_output = Pair{String,Any}[] + _openapi_value.architecture isa Absent || push!(_openapi_output, "architecture" => _openapi_value.architecture) + _openapi_value.bootid isa Absent || push!(_openapi_output, "bootID" => _openapi_value.bootid) + _openapi_value.containerruntimeversion isa Absent || push!(_openapi_output, "containerRuntimeVersion" => _openapi_value.containerruntimeversion) + _openapi_value.kernelversion isa Absent || push!(_openapi_output, "kernelVersion" => _openapi_value.kernelversion) + _openapi_value.kubeproxyversion isa Absent || push!(_openapi_output, "kubeProxyVersion" => _openapi_value.kubeproxyversion) + _openapi_value.kubeletversion isa Absent || push!(_openapi_output, "kubeletVersion" => _openapi_value.kubeletversion) + _openapi_value.machineid isa Absent || push!(_openapi_output, "machineID" => _openapi_value.machineid) + _openapi_value.operatingsystem isa Absent || push!(_openapi_output, "operatingSystem" => _openapi_value.operatingsystem) + _openapi_value.osimage isa Absent || push!(_openapi_output, "osImage" => _openapi_value.osimage) + _openapi_value.swap isa Absent || push!(_openapi_output, "swap" => _openapi_value.swap) + _openapi_value.systemuuid isa Absent || push!(_openapi_output, "systemUUID" => _openapi_value.systemuuid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeRuntimeHandlerFeatures + recursivereadonlymounts::Union{Absent,Bool,Nothing} = ABSENT + usernamespaces::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeRuntimeHandlerFeatures}, value) = _decode(IoK8sApiCoreV1NodeRuntimeHandlerFeatures, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeRuntimeHandlerFeatures}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures"), _openapi_raw, "decoding IoK8sApiCoreV1NodeRuntimeHandlerFeatures"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeRuntimeHandlerFeatures") + _openapi_field_recursivereadonlymounts = haskey(_openapi_object, "recursiveReadOnlyMounts") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["recursiveReadOnlyMounts"], _openapi_validate) : ABSENT + _openapi_field_usernamespaces = haskey(_openapi_object, "userNamespaces") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["userNamespaces"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("recursiveReadOnlyMounts","userNamespaces") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeRuntimeHandlerFeatures(; recursivereadonlymounts = _openapi_field_recursivereadonlymounts, usernamespaces = _openapi_field_usernamespaces, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeRuntimeHandlerFeatures) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.recursivereadonlymounts isa Absent || (_openapi_output["recursiveReadOnlyMounts"] = _encode(_openapi_value.recursivereadonlymounts)) + _openapi_value.usernamespaces isa Absent || (_openapi_output["userNamespaces"] = _encode(_openapi_value.usernamespaces)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandlerFeatures"), _openapi_output, "encoding IoK8sApiCoreV1NodeRuntimeHandlerFeatures"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeRuntimeHandlerFeatures) + _openapi_output = Pair{String,Any}[] + _openapi_value.recursivereadonlymounts isa Absent || push!(_openapi_output, "recursiveReadOnlyMounts" => _openapi_value.recursivereadonlymounts) + _openapi_value.usernamespaces isa Absent || push!(_openapi_output, "userNamespaces" => _openapi_value.usernamespaces) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeRuntimeHandler + features::Union{Absent,IoK8sApiCoreV1NodeRuntimeHandlerFeatures,Nothing} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeRuntimeHandler}, value) = _decode(IoK8sApiCoreV1NodeRuntimeHandler, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeRuntimeHandler}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler"), _openapi_raw, "decoding IoK8sApiCoreV1NodeRuntimeHandler"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeRuntimeHandler") + _openapi_field_features = haskey(_openapi_object, "features") ? _decode(Union{Absent,IoK8sApiCoreV1NodeRuntimeHandlerFeatures,Nothing}, _openapi_object["features"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("features","name") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeRuntimeHandler(; features = _openapi_field_features, name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeRuntimeHandler) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.features isa Absent || (_openapi_output["features"] = _encode(_openapi_value.features)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeRuntimeHandler"), _openapi_output, "encoding IoK8sApiCoreV1NodeRuntimeHandler"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeRuntimeHandler) + _openapi_output = Pair{String,Any}[] + _openapi_value.features isa Absent || push!(_openapi_output, "features" => _openapi_value.features) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeStatus + addresses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeAddress}}} = ABSENT + allocatable::Union{Absent,IoK8sApiCoreV1NodeStatusAllocatable,Nothing} = ABSENT + capacity::Union{Absent,IoK8sApiCoreV1NodeStatusCapacity,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeCondition}}} = ABSENT + config::Union{Absent,IoK8sApiCoreV1NodeConfigStatus,Nothing} = ABSENT + daemonendpoints::Union{Absent,IoK8sApiCoreV1NodeDaemonEndpoints,Nothing} = ABSENT + declaredfeatures::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + features::Union{Absent,IoK8sApiCoreV1NodeFeatures,Nothing} = ABSENT + images::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerImage}}} = ABSENT + nodeinfo::Union{Absent,IoK8sApiCoreV1NodeSystemInfo,Nothing} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + runtimehandlers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeRuntimeHandler}}} = ABSENT + volumesattached::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1AttachedVolume}}} = ABSENT + volumesinuse::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeStatus}, value) = _decode(IoK8sApiCoreV1NodeStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus"), _openapi_raw, "decoding IoK8sApiCoreV1NodeStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeStatus") + _openapi_field_addresses = haskey(_openapi_object, "addresses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeAddress}}}, _openapi_object["addresses"], _openapi_validate) : ABSENT + _openapi_field_allocatable = haskey(_openapi_object, "allocatable") ? _decode(Union{Absent,IoK8sApiCoreV1NodeStatusAllocatable,Nothing}, _openapi_object["allocatable"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApiCoreV1NodeStatusCapacity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_config = haskey(_openapi_object, "config") ? _decode(Union{Absent,IoK8sApiCoreV1NodeConfigStatus,Nothing}, _openapi_object["config"], _openapi_validate) : ABSENT + _openapi_field_daemonendpoints = haskey(_openapi_object, "daemonEndpoints") ? _decode(Union{Absent,IoK8sApiCoreV1NodeDaemonEndpoints,Nothing}, _openapi_object["daemonEndpoints"], _openapi_validate) : ABSENT + _openapi_field_declaredfeatures = haskey(_openapi_object, "declaredFeatures") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["declaredFeatures"], _openapi_validate) : ABSENT + _openapi_field_features = haskey(_openapi_object, "features") ? _decode(Union{Absent,IoK8sApiCoreV1NodeFeatures,Nothing}, _openapi_object["features"], _openapi_validate) : ABSENT + _openapi_field_images = haskey(_openapi_object, "images") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerImage}}}, _openapi_object["images"], _openapi_validate) : ABSENT + _openapi_field_nodeinfo = haskey(_openapi_object, "nodeInfo") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSystemInfo,Nothing}, _openapi_object["nodeInfo"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_field_runtimehandlers = haskey(_openapi_object, "runtimeHandlers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1NodeRuntimeHandler}}}, _openapi_object["runtimeHandlers"], _openapi_validate) : ABSENT + _openapi_field_volumesattached = haskey(_openapi_object, "volumesAttached") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1AttachedVolume}}}, _openapi_object["volumesAttached"], _openapi_validate) : ABSENT + _openapi_field_volumesinuse = haskey(_openapi_object, "volumesInUse") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["volumesInUse"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("addresses","allocatable","capacity","conditions","config","daemonEndpoints","declaredFeatures","features","images","nodeInfo","phase","runtimeHandlers","volumesAttached","volumesInUse") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeStatus(; addresses = _openapi_field_addresses, allocatable = _openapi_field_allocatable, capacity = _openapi_field_capacity, conditions = _openapi_field_conditions, config = _openapi_field_config, daemonendpoints = _openapi_field_daemonendpoints, declaredfeatures = _openapi_field_declaredfeatures, features = _openapi_field_features, images = _openapi_field_images, nodeinfo = _openapi_field_nodeinfo, phase = _openapi_field_phase, runtimehandlers = _openapi_field_runtimehandlers, volumesattached = _openapi_field_volumesattached, volumesinuse = _openapi_field_volumesinuse, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.addresses isa Absent || (_openapi_output["addresses"] = _encode(_openapi_value.addresses)) + _openapi_value.allocatable isa Absent || (_openapi_output["allocatable"] = _encode(_openapi_value.allocatable)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.config isa Absent || (_openapi_output["config"] = _encode(_openapi_value.config)) + _openapi_value.daemonendpoints isa Absent || (_openapi_output["daemonEndpoints"] = _encode(_openapi_value.daemonendpoints)) + _openapi_value.declaredfeatures isa Absent || (_openapi_output["declaredFeatures"] = _encode(_openapi_value.declaredfeatures)) + _openapi_value.features isa Absent || (_openapi_output["features"] = _encode(_openapi_value.features)) + _openapi_value.images isa Absent || (_openapi_output["images"] = _encode(_openapi_value.images)) + _openapi_value.nodeinfo isa Absent || (_openapi_output["nodeInfo"] = _encode(_openapi_value.nodeinfo)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + _openapi_value.runtimehandlers isa Absent || (_openapi_output["runtimeHandlers"] = _encode(_openapi_value.runtimehandlers)) + _openapi_value.volumesattached isa Absent || (_openapi_output["volumesAttached"] = _encode(_openapi_value.volumesattached)) + _openapi_value.volumesinuse isa Absent || (_openapi_output["volumesInUse"] = _encode(_openapi_value.volumesinuse)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeStatus"), _openapi_output, "encoding IoK8sApiCoreV1NodeStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.addresses isa Absent || push!(_openapi_output, "addresses" => _openapi_value.addresses) + _openapi_value.allocatable isa Absent || push!(_openapi_output, "allocatable" => _openapi_value.allocatable) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.config isa Absent || push!(_openapi_output, "config" => _openapi_value.config) + _openapi_value.daemonendpoints isa Absent || push!(_openapi_output, "daemonEndpoints" => _openapi_value.daemonendpoints) + _openapi_value.declaredfeatures isa Absent || push!(_openapi_output, "declaredFeatures" => _openapi_value.declaredfeatures) + _openapi_value.features isa Absent || push!(_openapi_output, "features" => _openapi_value.features) + _openapi_value.images isa Absent || push!(_openapi_output, "images" => _openapi_value.images) + _openapi_value.nodeinfo isa Absent || push!(_openapi_output, "nodeInfo" => _openapi_value.nodeinfo) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + _openapi_value.runtimehandlers isa Absent || push!(_openapi_output, "runtimeHandlers" => _openapi_value.runtimehandlers) + _openapi_value.volumesattached isa Absent || push!(_openapi_output, "volumesAttached" => _openapi_value.volumesattached) + _openapi_value.volumesinuse isa Absent || push!(_openapi_output, "volumesInUse" => _openapi_value.volumesinuse) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Node + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1NodeSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1NodeStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Node}, value) = _decode(IoK8sApiCoreV1Node, value, true) +function _decode(::Type{IoK8sApiCoreV1Node}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Node"), _openapi_raw, "decoding IoK8sApiCoreV1Node"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Node") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1NodeStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Node(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Node) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Node"), _openapi_output, "encoding IoK8sApiCoreV1Node"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Node) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1NodeList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Node}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1NodeList}, value) = _decode(IoK8sApiCoreV1NodeList, value, true) +function _decode(::Type{IoK8sApiCoreV1NodeList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeList"), _openapi_raw, "decoding IoK8sApiCoreV1NodeList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1NodeList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Node}}, _required(_openapi_object, "items", "IoK8sApiCoreV1NodeList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1NodeList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1NodeList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.NodeList"), _openapi_output, "encoding IoK8sApiCoreV1NodeList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1NodeList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeSpecCapacity + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeSpecCapacity}, value) = _decode(IoK8sApiCoreV1PersistentVolumeSpecCapacity, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeSpecCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec/properties/capacity"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeSpecCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeSpecCapacity") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeSpecCapacity(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpecCapacity) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec/properties/capacity"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeSpecCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpecCapacity) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeNodeAffinity + required::Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeNodeAffinity}, value) = _decode(IoK8sApiCoreV1VolumeNodeAffinity, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeNodeAffinity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeNodeAffinity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeNodeAffinity") + _openapi_field_required = haskey(_openapi_object, "required") ? _decode(Union{Absent,IoK8sApiCoreV1NodeSelector,Nothing}, _openapi_object["required"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("required",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeNodeAffinity(; required = _openapi_field_required, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeNodeAffinity) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.required isa Absent || (_openapi_output["required"] = _encode(_openapi_value.required)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeNodeAffinity"), _openapi_output, "encoding IoK8sApiCoreV1VolumeNodeAffinity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeNodeAffinity) + _openapi_output = Pair{String,Any}[] + _openapi_value.required isa Absent || push!(_openapi_output, "required" => _openapi_value.required) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PhotonPersistentDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + pdid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1PhotonPersistentDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PhotonPersistentDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_pdid = _decode(String, _required(_openapi_object, "pdID", "IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","pdID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PhotonPersistentDiskVolumeSource(; fstype = _openapi_field_fstype, pdid = _openapi_field_pdid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.pdid isa Absent || (_openapi_output["pdID"] = _encode(_openapi_value.pdid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PhotonPersistentDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PhotonPersistentDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.pdid isa Absent || push!(_openapi_output, "pdID" => _openapi_value.pdid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PortworxVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + volumeid::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, value) = _decode(IoK8sApiCoreV1PortworxVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PortworxVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PortworxVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_volumeid = _decode(String, _required(_openapi_object, "volumeID", "IoK8sApiCoreV1PortworxVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","volumeID") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PortworxVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, volumeid = _openapi_field_volumeid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.volumeid isa Absent || (_openapi_output["volumeID"] = _encode(_openapi_value.volumeid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PortworxVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PortworxVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PortworxVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.volumeid isa Absent || push!(_openapi_output, "volumeID" => _openapi_value.volumeid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1QuobyteVolumeSource + group::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + registry::String + tenant::Union{Absent,Nothing,String} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + volume::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, value) = _decode(IoK8sApiCoreV1QuobyteVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1QuobyteVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1QuobyteVolumeSource") + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_registry = _decode(String, _required(_openapi_object, "registry", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_field_tenant = haskey(_openapi_object, "tenant") ? _decode(Union{Absent,Nothing,String}, _openapi_object["tenant"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_field_volume = _decode(String, _required(_openapi_object, "volume", "IoK8sApiCoreV1QuobyteVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("group","readOnly","registry","tenant","user","volume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1QuobyteVolumeSource(; group = _openapi_field_group, readonly = _openapi_field_readonly, registry = _openapi_field_registry, tenant = _openapi_field_tenant, user = _openapi_field_user, volume = _openapi_field_volume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.registry isa Absent || (_openapi_output["registry"] = _encode(_openapi_value.registry)) + _openapi_value.tenant isa Absent || (_openapi_output["tenant"] = _encode(_openapi_value.tenant)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + _openapi_value.volume isa Absent || (_openapi_output["volume"] = _encode(_openapi_value.volume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.QuobyteVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1QuobyteVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1QuobyteVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.registry isa Absent || push!(_openapi_output, "registry" => _openapi_value.registry) + _openapi_value.tenant isa Absent || push!(_openapi_output, "tenant" => _openapi_value.tenant) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + _openapi_value.volume isa Absent || push!(_openapi_output, "volume" => _openapi_value.volume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1RBDPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + image::String + keyring::Union{Absent,Nothing,String} = ABSENT + monitors::Union{Nothing,Vector{String}} + pool::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1SecretReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1RBDPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1RBDPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1RBDPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1RBDPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1RBDPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1RBDPersistentVolumeSource"), _openapi_validate) + _openapi_field_keyring = haskey(_openapi_object, "keyring") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyring"], _openapi_validate) : ABSENT + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1RBDPersistentVolumeSource"), _openapi_validate) + _openapi_field_pool = haskey(_openapi_object, "pool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pool"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1SecretReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","image","keyring","monitors","pool","readOnly","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1RBDPersistentVolumeSource(; fstype = _openapi_field_fstype, image = _openapi_field_image, keyring = _openapi_field_keyring, monitors = _openapi_field_monitors, pool = _openapi_field_pool, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1RBDPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.keyring isa Absent || (_openapi_output["keyring"] = _encode(_openapi_value.keyring)) + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.pool isa Absent || (_openapi_output["pool"] = _encode(_openapi_value.pool)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1RBDPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1RBDPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.keyring isa Absent || push!(_openapi_output, "keyring" => _openapi_value.keyring) + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.pool isa Absent || push!(_openapi_output, "pool" => _openapi_value.pool) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScaleIOPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + gateway::String + protectiondomain::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::IoK8sApiCoreV1SecretReference + sslenabled::Union{Absent,Bool,Nothing} = ABSENT + storagemode::Union{Absent,Nothing,String} = ABSENT + storagepool::Union{Absent,Nothing,String} = ABSENT + system::String + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScaleIOPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1ScaleIOPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ScaleIOPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ScaleIOPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScaleIOPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_gateway = _decode(String, _required(_openapi_object, "gateway", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_protectiondomain = haskey(_openapi_object, "protectionDomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protectionDomain"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = _decode(IoK8sApiCoreV1SecretReference, _required(_openapi_object, "secretRef", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_sslenabled = haskey(_openapi_object, "sslEnabled") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["sslEnabled"], _openapi_validate) : ABSENT + _openapi_field_storagemode = haskey(_openapi_object, "storageMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageMode"], _openapi_validate) : ABSENT + _openapi_field_storagepool = haskey(_openapi_object, "storagePool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePool"], _openapi_validate) : ABSENT + _openapi_field_system = _decode(String, _required(_openapi_object, "system", "IoK8sApiCoreV1ScaleIOPersistentVolumeSource"), _openapi_validate) + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","gateway","protectionDomain","readOnly","secretRef","sslEnabled","storageMode","storagePool","system","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScaleIOPersistentVolumeSource(; fstype = _openapi_field_fstype, gateway = _openapi_field_gateway, protectiondomain = _openapi_field_protectiondomain, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, sslenabled = _openapi_field_sslenabled, storagemode = _openapi_field_storagemode, storagepool = _openapi_field_storagepool, system = _openapi_field_system, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScaleIOPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.gateway isa Absent || (_openapi_output["gateway"] = _encode(_openapi_value.gateway)) + _openapi_value.protectiondomain isa Absent || (_openapi_output["protectionDomain"] = _encode(_openapi_value.protectiondomain)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.sslenabled isa Absent || (_openapi_output["sslEnabled"] = _encode(_openapi_value.sslenabled)) + _openapi_value.storagemode isa Absent || (_openapi_output["storageMode"] = _encode(_openapi_value.storagemode)) + _openapi_value.storagepool isa Absent || (_openapi_output["storagePool"] = _encode(_openapi_value.storagepool)) + _openapi_value.system isa Absent || (_openapi_output["system"] = _encode(_openapi_value.system)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ScaleIOPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScaleIOPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.gateway isa Absent || push!(_openapi_output, "gateway" => _openapi_value.gateway) + _openapi_value.protectiondomain isa Absent || push!(_openapi_output, "protectionDomain" => _openapi_value.protectiondomain) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.sslenabled isa Absent || push!(_openapi_output, "sslEnabled" => _openapi_value.sslenabled) + _openapi_value.storagemode isa Absent || push!(_openapi_output, "storageMode" => _openapi_value.storagemode) + _openapi_value.storagepool isa Absent || push!(_openapi_output, "storagePool" => _openapi_value.storagepool) + _openapi_value.system isa Absent || push!(_openapi_output, "system" => _openapi_value.system) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1StorageOSPersistentVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + volumenamespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1StorageOSPersistentVolumeSource}, value) = _decode(IoK8sApiCoreV1StorageOSPersistentVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1StorageOSPersistentVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1StorageOSPersistentVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1StorageOSPersistentVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_field_volumenamespace = haskey(_openapi_object, "volumeNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeNamespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeName","volumeNamespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1StorageOSPersistentVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumename = _openapi_field_volumename, volumenamespace = _openapi_field_volumenamespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1StorageOSPersistentVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + _openapi_value.volumenamespace isa Absent || (_openapi_output["volumeNamespace"] = _encode(_openapi_value.volumenamespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSPersistentVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1StorageOSPersistentVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1StorageOSPersistentVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + _openapi_value.volumenamespace isa Absent || push!(_openapi_output, "volumeNamespace" => _openapi_value.volumenamespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VsphereVirtualDiskVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + storagepolicyid::Union{Absent,Nothing,String} = ABSENT + storagepolicyname::Union{Absent,Nothing,String} = ABSENT + volumepath::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, value) = _decode(IoK8sApiCoreV1VsphereVirtualDiskVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1VsphereVirtualDiskVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyid = haskey(_openapi_object, "storagePolicyID") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyID"], _openapi_validate) : ABSENT + _openapi_field_storagepolicyname = haskey(_openapi_object, "storagePolicyName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePolicyName"], _openapi_validate) : ABSENT + _openapi_field_volumepath = _decode(String, _required(_openapi_object, "volumePath", "IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","storagePolicyID","storagePolicyName","volumePath") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VsphereVirtualDiskVolumeSource(; fstype = _openapi_field_fstype, storagepolicyid = _openapi_field_storagepolicyid, storagepolicyname = _openapi_field_storagepolicyname, volumepath = _openapi_field_volumepath, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.storagepolicyid isa Absent || (_openapi_output["storagePolicyID"] = _encode(_openapi_value.storagepolicyid)) + _openapi_value.storagepolicyname isa Absent || (_openapi_output["storagePolicyName"] = _encode(_openapi_value.storagepolicyname)) + _openapi_value.volumepath isa Absent || (_openapi_output["volumePath"] = _encode(_openapi_value.volumepath)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1VsphereVirtualDiskVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VsphereVirtualDiskVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.storagepolicyid isa Absent || push!(_openapi_output, "storagePolicyID" => _openapi_value.storagepolicyid) + _openapi_value.storagepolicyname isa Absent || push!(_openapi_output, "storagePolicyName" => _openapi_value.storagepolicyname) + _openapi_value.volumepath isa Absent || push!(_openapi_output, "volumePath" => _openapi_value.volumepath) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeSpec + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + awselasticblockstore::Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing} = ABSENT + azuredisk::Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing} = ABSENT + azurefile::Union{Absent,IoK8sApiCoreV1AzureFilePersistentVolumeSource,Nothing} = ABSENT + capacity::Union{Absent,IoK8sApiCoreV1PersistentVolumeSpecCapacity,Nothing} = ABSENT + cephfs::Union{Absent,IoK8sApiCoreV1CephFSPersistentVolumeSource,Nothing} = ABSENT + cinder::Union{Absent,IoK8sApiCoreV1CinderPersistentVolumeSource,Nothing} = ABSENT + claimref::Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing} = ABSENT + csi::Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSource,Nothing} = ABSENT + fc::Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing} = ABSENT + flexvolume::Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSource,Nothing} = ABSENT + flocker::Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing} = ABSENT + gcepersistentdisk::Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing} = ABSENT + glusterfs::Union{Absent,IoK8sApiCoreV1GlusterfsPersistentVolumeSource,Nothing} = ABSENT + hostpath::Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing} = ABSENT + iscsi::Union{Absent,IoK8sApiCoreV1ISCSIPersistentVolumeSource,Nothing} = ABSENT + local_::Union{Absent,IoK8sApiCoreV1LocalVolumeSource,Nothing} = ABSENT + mountoptions::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + nfs::Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing} = ABSENT + nodeaffinity::Union{Absent,IoK8sApiCoreV1VolumeNodeAffinity,Nothing} = ABSENT + persistentvolumereclaimpolicy::Union{Absent,Nothing,String} = ABSENT + photonpersistentdisk::Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing} = ABSENT + portworxvolume::Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing} = ABSENT + quobyte::Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing} = ABSENT + rbd::Union{Absent,IoK8sApiCoreV1RBDPersistentVolumeSource,Nothing} = ABSENT + scaleio::Union{Absent,IoK8sApiCoreV1ScaleIOPersistentVolumeSource,Nothing} = ABSENT + storageclassname::Union{Absent,Nothing,String} = ABSENT + storageos::Union{Absent,IoK8sApiCoreV1StorageOSPersistentVolumeSource,Nothing} = ABSENT + volumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + volumemode::Union{Absent,Nothing,String} = ABSENT + vspherevolume::Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeSpec}, value) = _decode(IoK8sApiCoreV1PersistentVolumeSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeSpec") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_awselasticblockstore = haskey(_openapi_object, "awsElasticBlockStore") ? _decode(Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing}, _openapi_object["awsElasticBlockStore"], _openapi_validate) : ABSENT + _openapi_field_azuredisk = haskey(_openapi_object, "azureDisk") ? _decode(Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing}, _openapi_object["azureDisk"], _openapi_validate) : ABSENT + _openapi_field_azurefile = haskey(_openapi_object, "azureFile") ? _decode(Union{Absent,IoK8sApiCoreV1AzureFilePersistentVolumeSource,Nothing}, _openapi_object["azureFile"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeSpecCapacity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_cephfs = haskey(_openapi_object, "cephfs") ? _decode(Union{Absent,IoK8sApiCoreV1CephFSPersistentVolumeSource,Nothing}, _openapi_object["cephfs"], _openapi_validate) : ABSENT + _openapi_field_cinder = haskey(_openapi_object, "cinder") ? _decode(Union{Absent,IoK8sApiCoreV1CinderPersistentVolumeSource,Nothing}, _openapi_object["cinder"], _openapi_validate) : ABSENT + _openapi_field_claimref = haskey(_openapi_object, "claimRef") ? _decode(Union{Absent,IoK8sApiCoreV1ObjectReference,Nothing}, _openapi_object["claimRef"], _openapi_validate) : ABSENT + _openapi_field_csi = haskey(_openapi_object, "csi") ? _decode(Union{Absent,IoK8sApiCoreV1CSIPersistentVolumeSource,Nothing}, _openapi_object["csi"], _openapi_validate) : ABSENT + _openapi_field_fc = haskey(_openapi_object, "fc") ? _decode(Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing}, _openapi_object["fc"], _openapi_validate) : ABSENT + _openapi_field_flexvolume = haskey(_openapi_object, "flexVolume") ? _decode(Union{Absent,IoK8sApiCoreV1FlexPersistentVolumeSource,Nothing}, _openapi_object["flexVolume"], _openapi_validate) : ABSENT + _openapi_field_flocker = haskey(_openapi_object, "flocker") ? _decode(Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing}, _openapi_object["flocker"], _openapi_validate) : ABSENT + _openapi_field_gcepersistentdisk = haskey(_openapi_object, "gcePersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing}, _openapi_object["gcePersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_glusterfs = haskey(_openapi_object, "glusterfs") ? _decode(Union{Absent,IoK8sApiCoreV1GlusterfsPersistentVolumeSource,Nothing}, _openapi_object["glusterfs"], _openapi_validate) : ABSENT + _openapi_field_hostpath = haskey(_openapi_object, "hostPath") ? _decode(Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing}, _openapi_object["hostPath"], _openapi_validate) : ABSENT + _openapi_field_iscsi = haskey(_openapi_object, "iscsi") ? _decode(Union{Absent,IoK8sApiCoreV1ISCSIPersistentVolumeSource,Nothing}, _openapi_object["iscsi"], _openapi_validate) : ABSENT + _openapi_field_local_ = haskey(_openapi_object, "local") ? _decode(Union{Absent,IoK8sApiCoreV1LocalVolumeSource,Nothing}, _openapi_object["local"], _openapi_validate) : ABSENT + _openapi_field_mountoptions = haskey(_openapi_object, "mountOptions") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["mountOptions"], _openapi_validate) : ABSENT + _openapi_field_nfs = haskey(_openapi_object, "nfs") ? _decode(Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing}, _openapi_object["nfs"], _openapi_validate) : ABSENT + _openapi_field_nodeaffinity = haskey(_openapi_object, "nodeAffinity") ? _decode(Union{Absent,IoK8sApiCoreV1VolumeNodeAffinity,Nothing}, _openapi_object["nodeAffinity"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumereclaimpolicy = haskey(_openapi_object, "persistentVolumeReclaimPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["persistentVolumeReclaimPolicy"], _openapi_validate) : ABSENT + _openapi_field_photonpersistentdisk = haskey(_openapi_object, "photonPersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing}, _openapi_object["photonPersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_portworxvolume = haskey(_openapi_object, "portworxVolume") ? _decode(Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing}, _openapi_object["portworxVolume"], _openapi_validate) : ABSENT + _openapi_field_quobyte = haskey(_openapi_object, "quobyte") ? _decode(Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing}, _openapi_object["quobyte"], _openapi_validate) : ABSENT + _openapi_field_rbd = haskey(_openapi_object, "rbd") ? _decode(Union{Absent,IoK8sApiCoreV1RBDPersistentVolumeSource,Nothing}, _openapi_object["rbd"], _openapi_validate) : ABSENT + _openapi_field_scaleio = haskey(_openapi_object, "scaleIO") ? _decode(Union{Absent,IoK8sApiCoreV1ScaleIOPersistentVolumeSource,Nothing}, _openapi_object["scaleIO"], _openapi_validate) : ABSENT + _openapi_field_storageclassname = haskey(_openapi_object, "storageClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageClassName"], _openapi_validate) : ABSENT + _openapi_field_storageos = haskey(_openapi_object, "storageos") ? _decode(Union{Absent,IoK8sApiCoreV1StorageOSPersistentVolumeSource,Nothing}, _openapi_object["storageos"], _openapi_validate) : ABSENT + _openapi_field_volumeattributesclassname = haskey(_openapi_object, "volumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_volumemode = haskey(_openapi_object, "volumeMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeMode"], _openapi_validate) : ABSENT + _openapi_field_vspherevolume = haskey(_openapi_object, "vsphereVolume") ? _decode(Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing}, _openapi_object["vsphereVolume"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","awsElasticBlockStore","azureDisk","azureFile","capacity","cephfs","cinder","claimRef","csi","fc","flexVolume","flocker","gcePersistentDisk","glusterfs","hostPath","iscsi","local","mountOptions","nfs","nodeAffinity","persistentVolumeReclaimPolicy","photonPersistentDisk","portworxVolume","quobyte","rbd","scaleIO","storageClassName","storageos","volumeAttributesClassName","volumeMode","vsphereVolume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeSpec(; accessmodes = _openapi_field_accessmodes, awselasticblockstore = _openapi_field_awselasticblockstore, azuredisk = _openapi_field_azuredisk, azurefile = _openapi_field_azurefile, capacity = _openapi_field_capacity, cephfs = _openapi_field_cephfs, cinder = _openapi_field_cinder, claimref = _openapi_field_claimref, csi = _openapi_field_csi, fc = _openapi_field_fc, flexvolume = _openapi_field_flexvolume, flocker = _openapi_field_flocker, gcepersistentdisk = _openapi_field_gcepersistentdisk, glusterfs = _openapi_field_glusterfs, hostpath = _openapi_field_hostpath, iscsi = _openapi_field_iscsi, local_ = _openapi_field_local_, mountoptions = _openapi_field_mountoptions, nfs = _openapi_field_nfs, nodeaffinity = _openapi_field_nodeaffinity, persistentvolumereclaimpolicy = _openapi_field_persistentvolumereclaimpolicy, photonpersistentdisk = _openapi_field_photonpersistentdisk, portworxvolume = _openapi_field_portworxvolume, quobyte = _openapi_field_quobyte, rbd = _openapi_field_rbd, scaleio = _openapi_field_scaleio, storageclassname = _openapi_field_storageclassname, storageos = _openapi_field_storageos, volumeattributesclassname = _openapi_field_volumeattributesclassname, volumemode = _openapi_field_volumemode, vspherevolume = _openapi_field_vspherevolume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.awselasticblockstore isa Absent || (_openapi_output["awsElasticBlockStore"] = _encode(_openapi_value.awselasticblockstore)) + _openapi_value.azuredisk isa Absent || (_openapi_output["azureDisk"] = _encode(_openapi_value.azuredisk)) + _openapi_value.azurefile isa Absent || (_openapi_output["azureFile"] = _encode(_openapi_value.azurefile)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.cephfs isa Absent || (_openapi_output["cephfs"] = _encode(_openapi_value.cephfs)) + _openapi_value.cinder isa Absent || (_openapi_output["cinder"] = _encode(_openapi_value.cinder)) + _openapi_value.claimref isa Absent || (_openapi_output["claimRef"] = _encode(_openapi_value.claimref)) + _openapi_value.csi isa Absent || (_openapi_output["csi"] = _encode(_openapi_value.csi)) + _openapi_value.fc isa Absent || (_openapi_output["fc"] = _encode(_openapi_value.fc)) + _openapi_value.flexvolume isa Absent || (_openapi_output["flexVolume"] = _encode(_openapi_value.flexvolume)) + _openapi_value.flocker isa Absent || (_openapi_output["flocker"] = _encode(_openapi_value.flocker)) + _openapi_value.gcepersistentdisk isa Absent || (_openapi_output["gcePersistentDisk"] = _encode(_openapi_value.gcepersistentdisk)) + _openapi_value.glusterfs isa Absent || (_openapi_output["glusterfs"] = _encode(_openapi_value.glusterfs)) + _openapi_value.hostpath isa Absent || (_openapi_output["hostPath"] = _encode(_openapi_value.hostpath)) + _openapi_value.iscsi isa Absent || (_openapi_output["iscsi"] = _encode(_openapi_value.iscsi)) + _openapi_value.local_ isa Absent || (_openapi_output["local"] = _encode(_openapi_value.local_)) + _openapi_value.mountoptions isa Absent || (_openapi_output["mountOptions"] = _encode(_openapi_value.mountoptions)) + _openapi_value.nfs isa Absent || (_openapi_output["nfs"] = _encode(_openapi_value.nfs)) + _openapi_value.nodeaffinity isa Absent || (_openapi_output["nodeAffinity"] = _encode(_openapi_value.nodeaffinity)) + _openapi_value.persistentvolumereclaimpolicy isa Absent || (_openapi_output["persistentVolumeReclaimPolicy"] = _encode(_openapi_value.persistentvolumereclaimpolicy)) + _openapi_value.photonpersistentdisk isa Absent || (_openapi_output["photonPersistentDisk"] = _encode(_openapi_value.photonpersistentdisk)) + _openapi_value.portworxvolume isa Absent || (_openapi_output["portworxVolume"] = _encode(_openapi_value.portworxvolume)) + _openapi_value.quobyte isa Absent || (_openapi_output["quobyte"] = _encode(_openapi_value.quobyte)) + _openapi_value.rbd isa Absent || (_openapi_output["rbd"] = _encode(_openapi_value.rbd)) + _openapi_value.scaleio isa Absent || (_openapi_output["scaleIO"] = _encode(_openapi_value.scaleio)) + _openapi_value.storageclassname isa Absent || (_openapi_output["storageClassName"] = _encode(_openapi_value.storageclassname)) + _openapi_value.storageos isa Absent || (_openapi_output["storageos"] = _encode(_openapi_value.storageos)) + _openapi_value.volumeattributesclassname isa Absent || (_openapi_output["volumeAttributesClassName"] = _encode(_openapi_value.volumeattributesclassname)) + _openapi_value.volumemode isa Absent || (_openapi_output["volumeMode"] = _encode(_openapi_value.volumemode)) + _openapi_value.vspherevolume isa Absent || (_openapi_output["vsphereVolume"] = _encode(_openapi_value.vspherevolume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeSpec"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.awselasticblockstore isa Absent || push!(_openapi_output, "awsElasticBlockStore" => _openapi_value.awselasticblockstore) + _openapi_value.azuredisk isa Absent || push!(_openapi_output, "azureDisk" => _openapi_value.azuredisk) + _openapi_value.azurefile isa Absent || push!(_openapi_output, "azureFile" => _openapi_value.azurefile) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.cephfs isa Absent || push!(_openapi_output, "cephfs" => _openapi_value.cephfs) + _openapi_value.cinder isa Absent || push!(_openapi_output, "cinder" => _openapi_value.cinder) + _openapi_value.claimref isa Absent || push!(_openapi_output, "claimRef" => _openapi_value.claimref) + _openapi_value.csi isa Absent || push!(_openapi_output, "csi" => _openapi_value.csi) + _openapi_value.fc isa Absent || push!(_openapi_output, "fc" => _openapi_value.fc) + _openapi_value.flexvolume isa Absent || push!(_openapi_output, "flexVolume" => _openapi_value.flexvolume) + _openapi_value.flocker isa Absent || push!(_openapi_output, "flocker" => _openapi_value.flocker) + _openapi_value.gcepersistentdisk isa Absent || push!(_openapi_output, "gcePersistentDisk" => _openapi_value.gcepersistentdisk) + _openapi_value.glusterfs isa Absent || push!(_openapi_output, "glusterfs" => _openapi_value.glusterfs) + _openapi_value.hostpath isa Absent || push!(_openapi_output, "hostPath" => _openapi_value.hostpath) + _openapi_value.iscsi isa Absent || push!(_openapi_output, "iscsi" => _openapi_value.iscsi) + _openapi_value.local_ isa Absent || push!(_openapi_output, "local" => _openapi_value.local_) + _openapi_value.mountoptions isa Absent || push!(_openapi_output, "mountOptions" => _openapi_value.mountoptions) + _openapi_value.nfs isa Absent || push!(_openapi_output, "nfs" => _openapi_value.nfs) + _openapi_value.nodeaffinity isa Absent || push!(_openapi_output, "nodeAffinity" => _openapi_value.nodeaffinity) + _openapi_value.persistentvolumereclaimpolicy isa Absent || push!(_openapi_output, "persistentVolumeReclaimPolicy" => _openapi_value.persistentvolumereclaimpolicy) + _openapi_value.photonpersistentdisk isa Absent || push!(_openapi_output, "photonPersistentDisk" => _openapi_value.photonpersistentdisk) + _openapi_value.portworxvolume isa Absent || push!(_openapi_output, "portworxVolume" => _openapi_value.portworxvolume) + _openapi_value.quobyte isa Absent || push!(_openapi_output, "quobyte" => _openapi_value.quobyte) + _openapi_value.rbd isa Absent || push!(_openapi_output, "rbd" => _openapi_value.rbd) + _openapi_value.scaleio isa Absent || push!(_openapi_output, "scaleIO" => _openapi_value.scaleio) + _openapi_value.storageclassname isa Absent || push!(_openapi_output, "storageClassName" => _openapi_value.storageclassname) + _openapi_value.storageos isa Absent || push!(_openapi_output, "storageos" => _openapi_value.storageos) + _openapi_value.volumeattributesclassname isa Absent || push!(_openapi_output, "volumeAttributesClassName" => _openapi_value.volumeattributesclassname) + _openapi_value.volumemode isa Absent || push!(_openapi_output, "volumeMode" => _openapi_value.volumemode) + _openapi_value.vspherevolume isa Absent || push!(_openapi_output, "vsphereVolume" => _openapi_value.vspherevolume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeStatus + lastphasetransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeStatus}, value) = _decode(IoK8sApiCoreV1PersistentVolumeStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeStatus") + _openapi_field_lastphasetransitiontime = haskey(_openapi_object, "lastPhaseTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastPhaseTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastPhaseTransitionTime","message","phase","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeStatus(; lastphasetransitiontime = _openapi_field_lastphasetransitiontime, message = _openapi_field_message, phase = _openapi_field_phase, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastphasetransitiontime isa Absent || (_openapi_output["lastPhaseTransitionTime"] = _encode(_openapi_value.lastphasetransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeStatus"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastphasetransitiontime isa Absent || push!(_openapi_output, "lastPhaseTransitionTime" => _openapi_value.lastphasetransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolume + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PersistentVolumeSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1PersistentVolumeStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolume}, value) = _decode(IoK8sApiCoreV1PersistentVolume, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolume}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolume"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolume"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolume") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolume(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolume) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolume"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolume"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolume) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResourceStatuses"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResourceStatuses"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResources"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/allocatedResources"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/capacity"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus/properties/capacity"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimCondition + lastprobetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimCondition}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimCondition") + _openapi_field_lastprobetime = haskey(_openapi_object, "lastProbeTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastProbeTime"], _openapi_validate) : ABSENT + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1PersistentVolumeClaimCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1PersistentVolumeClaimCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastProbeTime","lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimCondition(; lastprobetime = _openapi_field_lastprobetime, lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastprobetime isa Absent || (_openapi_output["lastProbeTime"] = _encode(_openapi_value.lastprobetime)) + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimCondition"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastprobetime isa Absent || push!(_openapi_output, "lastProbeTime" => _openapi_value.lastprobetime) + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimStatus + accessmodes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + allocatedresourcestatuses::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses,Nothing} = ABSENT + allocatedresources::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources,Nothing} = ABSENT + capacity::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition}}} = ABSENT + currentvolumeattributesclassname::Union{Absent,Nothing,String} = ABSENT + modifyvolumestatus::Union{Absent,IoK8sApiCoreV1ModifyVolumeStatus,Nothing} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatus}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimStatus") + _openapi_field_accessmodes = haskey(_openapi_object, "accessModes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["accessModes"], _openapi_validate) : ABSENT + _openapi_field_allocatedresourcestatuses = haskey(_openapi_object, "allocatedResourceStatuses") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResourceStatuses,Nothing}, _openapi_object["allocatedResourceStatuses"], _openapi_validate) : ABSENT + _openapi_field_allocatedresources = haskey(_openapi_object, "allocatedResources") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusAllocatedResources,Nothing}, _openapi_object["allocatedResources"], _openapi_validate) : ABSENT + _openapi_field_capacity = haskey(_openapi_object, "capacity") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatusCapacity,Nothing}, _openapi_object["capacity"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaimCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_currentvolumeattributesclassname = haskey(_openapi_object, "currentVolumeAttributesClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["currentVolumeAttributesClassName"], _openapi_validate) : ABSENT + _openapi_field_modifyvolumestatus = haskey(_openapi_object, "modifyVolumeStatus") ? _decode(Union{Absent,IoK8sApiCoreV1ModifyVolumeStatus,Nothing}, _openapi_object["modifyVolumeStatus"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("accessModes","allocatedResourceStatuses","allocatedResources","capacity","conditions","currentVolumeAttributesClassName","modifyVolumeStatus","phase") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimStatus(; accessmodes = _openapi_field_accessmodes, allocatedresourcestatuses = _openapi_field_allocatedresourcestatuses, allocatedresources = _openapi_field_allocatedresources, capacity = _openapi_field_capacity, conditions = _openapi_field_conditions, currentvolumeattributesclassname = _openapi_field_currentvolumeattributesclassname, modifyvolumestatus = _openapi_field_modifyvolumestatus, phase = _openapi_field_phase, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.accessmodes isa Absent || (_openapi_output["accessModes"] = _encode(_openapi_value.accessmodes)) + _openapi_value.allocatedresourcestatuses isa Absent || (_openapi_output["allocatedResourceStatuses"] = _encode(_openapi_value.allocatedresourcestatuses)) + _openapi_value.allocatedresources isa Absent || (_openapi_output["allocatedResources"] = _encode(_openapi_value.allocatedresources)) + _openapi_value.capacity isa Absent || (_openapi_output["capacity"] = _encode(_openapi_value.capacity)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.currentvolumeattributesclassname isa Absent || (_openapi_output["currentVolumeAttributesClassName"] = _encode(_openapi_value.currentvolumeattributesclassname)) + _openapi_value.modifyvolumestatus isa Absent || (_openapi_output["modifyVolumeStatus"] = _encode(_openapi_value.modifyvolumestatus)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimStatus"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.accessmodes isa Absent || push!(_openapi_output, "accessModes" => _openapi_value.accessmodes) + _openapi_value.allocatedresourcestatuses isa Absent || push!(_openapi_output, "allocatedResourceStatuses" => _openapi_value.allocatedresourcestatuses) + _openapi_value.allocatedresources isa Absent || push!(_openapi_output, "allocatedResources" => _openapi_value.allocatedresources) + _openapi_value.capacity isa Absent || push!(_openapi_output, "capacity" => _openapi_value.capacity) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.currentvolumeattributesclassname isa Absent || push!(_openapi_output, "currentVolumeAttributesClassName" => _openapi_value.currentvolumeattributesclassname) + _openapi_value.modifyvolumestatus isa Absent || push!(_openapi_output, "modifyVolumeStatus" => _openapi_value.modifyvolumestatus) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaim + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaim}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaim") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaim(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaim"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaim}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimList}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimList, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolumeClaim}}, _required(_openapi_object, "items", "IoK8sApiCoreV1PersistentVolumeClaimList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimList"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeClaimVolumeSource + claimname::String + readonly::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, value) = _decode(IoK8sApiCoreV1PersistentVolumeClaimVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeClaimVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource") + _openapi_field_claimname = _decode(String, _required(_openapi_object, "claimName", "IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"), _openapi_validate) + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("claimName","readOnly") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeClaimVolumeSource(; claimname = _openapi_field_claimname, readonly = _openapi_field_readonly, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.claimname isa Absent || (_openapi_output["claimName"] = _encode(_openapi_value.claimname)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeClaimVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeClaimVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.claimname isa Absent || push!(_openapi_output, "claimName" => _openapi_value.claimname) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PersistentVolumeList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolume}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PersistentVolumeList}, value) = _decode(IoK8sApiCoreV1PersistentVolumeList, value, true) +function _decode(::Type{IoK8sApiCoreV1PersistentVolumeList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeList"), _openapi_raw, "decoding IoK8sApiCoreV1PersistentVolumeList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PersistentVolumeList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1PersistentVolume}}, _required(_openapi_object, "items", "IoK8sApiCoreV1PersistentVolumeList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PersistentVolumeList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PersistentVolumeList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PersistentVolumeList"), _openapi_output, "encoding IoK8sApiCoreV1PersistentVolumeList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PersistentVolumeList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfigOption + name::Union{Absent,Nothing,String} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, value) = _decode(IoK8sApiCoreV1PodDNSConfigOption, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfigOption}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfigOption") + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfigOption(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfigOption"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfigOption"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfigOption) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodDNSConfig + nameservers::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + options::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}} = ABSENT + searches::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodDNSConfig}, value) = _decode(IoK8sApiCoreV1PodDNSConfig, value, true) +function _decode(::Type{IoK8sApiCoreV1PodDNSConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_raw, "decoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodDNSConfig") + _openapi_field_nameservers = haskey(_openapi_object, "nameservers") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["nameservers"], _openapi_validate) : ABSENT + _openapi_field_options = haskey(_openapi_object, "options") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodDNSConfigOption}}}, _openapi_object["options"], _openapi_validate) : ABSENT + _openapi_field_searches = haskey(_openapi_object, "searches") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["searches"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("nameservers","options","searches") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodDNSConfig(; nameservers = _openapi_field_nameservers, options = _openapi_field_options, searches = _openapi_field_searches, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.nameservers isa Absent || (_openapi_output["nameservers"] = _encode(_openapi_value.nameservers)) + _openapi_value.options isa Absent || (_openapi_output["options"] = _encode(_openapi_value.options)) + _openapi_value.searches isa Absent || (_openapi_output["searches"] = _encode(_openapi_value.searches)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodDNSConfig"), _openapi_output, "encoding IoK8sApiCoreV1PodDNSConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodDNSConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.nameservers isa Absent || push!(_openapi_output, "nameservers" => _openapi_value.nameservers) + _openapi_value.options isa Absent || push!(_openapi_output, "options" => _openapi_value.options) + _openapi_value.searches isa Absent || push!(_openapi_output, "searches" => _openapi_value.searches) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecNodeSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, value) = _decode(IoK8sApiCoreV1PodSpecNodeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecNodeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecNodeSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecNodeSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/nodeSelector"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecNodeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecNodeSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodOS + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodOS}, value) = _decode(IoK8sApiCoreV1PodOS, value, true) +function _decode(::Type{IoK8sApiCoreV1PodOS}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_raw, "decoding IoK8sApiCoreV1PodOS"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodOS") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodOS"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodOS(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodOS"), _openapi_output, "encoding IoK8sApiCoreV1PodOS"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodOS) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpecOverhead + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, value) = _decode(IoK8sApiCoreV1PodSpecOverhead, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpecOverhead}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpecOverhead") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpecOverhead(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec/properties/overhead"), _openapi_output, "encoding IoK8sApiCoreV1PodSpecOverhead"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpecOverhead) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodReadinessGate + conditiontype::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodReadinessGate}, value) = _decode(IoK8sApiCoreV1PodReadinessGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodReadinessGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodReadinessGate") + _openapi_field_conditiontype = _decode(String, _required(_openapi_object, "conditionType", "IoK8sApiCoreV1PodReadinessGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditionType",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodReadinessGate(; conditiontype = _openapi_field_conditiontype, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditiontype isa Absent || (_openapi_output["conditionType"] = _encode(_openapi_value.conditiontype)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodReadinessGate"), _openapi_output, "encoding IoK8sApiCoreV1PodReadinessGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodReadinessGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditiontype isa Absent || push!(_openapi_output, "conditionType" => _openapi_value.conditiontype) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodResourceClaim + name::String + resourceclaimname::Union{Absent,Nothing,String} = ABSENT + resourceclaimtemplatename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodResourceClaim}, value) = _decode(IoK8sApiCoreV1PodResourceClaim, value, true) +function _decode(::Type{IoK8sApiCoreV1PodResourceClaim}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_raw, "decoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodResourceClaim") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodResourceClaim"), _openapi_validate) + _openapi_field_resourceclaimname = haskey(_openapi_object, "resourceClaimName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimName"], _openapi_validate) : ABSENT + _openapi_field_resourceclaimtemplatename = haskey(_openapi_object, "resourceClaimTemplateName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimTemplateName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","resourceClaimName","resourceClaimTemplateName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodResourceClaim(; name = _openapi_field_name, resourceclaimname = _openapi_field_resourceclaimname, resourceclaimtemplatename = _openapi_field_resourceclaimtemplatename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.resourceclaimname isa Absent || (_openapi_output["resourceClaimName"] = _encode(_openapi_value.resourceclaimname)) + _openapi_value.resourceclaimtemplatename isa Absent || (_openapi_output["resourceClaimTemplateName"] = _encode(_openapi_value.resourceclaimtemplatename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaim"), _openapi_output, "encoding IoK8sApiCoreV1PodResourceClaim"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodResourceClaim) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.resourceclaimname isa Absent || push!(_openapi_output, "resourceClaimName" => _openapi_value.resourceclaimname) + _openapi_value.resourceclaimtemplatename isa Absent || push!(_openapi_output, "resourceClaimTemplateName" => _openapi_value.resourceclaimtemplatename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSchedulingGate + name::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, value) = _decode(IoK8sApiCoreV1PodSchedulingGate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSchedulingGate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_raw, "decoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSchedulingGate") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodSchedulingGate"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSchedulingGate(; name = _openapi_field_name, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSchedulingGate"), _openapi_output, "encoding IoK8sApiCoreV1PodSchedulingGate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSchedulingGate) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Sysctl + name::String + value::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Sysctl}, value) = _decode(IoK8sApiCoreV1Sysctl, value, true) +function _decode(::Type{IoK8sApiCoreV1Sysctl}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_raw, "decoding IoK8sApiCoreV1Sysctl"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Sysctl") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_field_value = _decode(String, _required(_openapi_object, "value", "IoK8sApiCoreV1Sysctl"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Sysctl(; name = _openapi_field_name, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Sysctl"), _openapi_output, "encoding IoK8sApiCoreV1Sysctl"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Sysctl) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSecurityContext + apparmorprofile::Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing} = ABSENT + fsgroup::Union{Absent,Int64,Nothing} = ABSENT + fsgroupchangepolicy::Union{Absent,Nothing,String} = ABSENT + runasgroup::Union{Absent,Int64,Nothing} = ABSENT + runasnonroot::Union{Absent,Bool,Nothing} = ABSENT + runasuser::Union{Absent,Int64,Nothing} = ABSENT + selinuxchangepolicy::Union{Absent,Nothing,String} = ABSENT + selinuxoptions::Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing} = ABSENT + seccompprofile::Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing} = ABSENT + supplementalgroups::Union{Absent,Union{Nothing,Vector{Int64}}} = ABSENT + supplementalgroupspolicy::Union{Absent,Nothing,String} = ABSENT + sysctls::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}} = ABSENT + windowsoptions::Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSecurityContext}, value) = _decode(IoK8sApiCoreV1PodSecurityContext, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSecurityContext}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_raw, "decoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSecurityContext") + _openapi_field_apparmorprofile = haskey(_openapi_object, "appArmorProfile") ? _decode(Union{Absent,IoK8sApiCoreV1AppArmorProfile,Nothing}, _openapi_object["appArmorProfile"], _openapi_validate) : ABSENT + _openapi_field_fsgroup = haskey(_openapi_object, "fsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["fsGroup"], _openapi_validate) : ABSENT + _openapi_field_fsgroupchangepolicy = haskey(_openapi_object, "fsGroupChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsGroupChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_runasgroup = haskey(_openapi_object, "runAsGroup") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsGroup"], _openapi_validate) : ABSENT + _openapi_field_runasnonroot = haskey(_openapi_object, "runAsNonRoot") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["runAsNonRoot"], _openapi_validate) : ABSENT + _openapi_field_runasuser = haskey(_openapi_object, "runAsUser") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["runAsUser"], _openapi_validate) : ABSENT + _openapi_field_selinuxchangepolicy = haskey(_openapi_object, "seLinuxChangePolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["seLinuxChangePolicy"], _openapi_validate) : ABSENT + _openapi_field_selinuxoptions = haskey(_openapi_object, "seLinuxOptions") ? _decode(Union{Absent,IoK8sApiCoreV1SELinuxOptions,Nothing}, _openapi_object["seLinuxOptions"], _openapi_validate) : ABSENT + _openapi_field_seccompprofile = haskey(_openapi_object, "seccompProfile") ? _decode(Union{Absent,IoK8sApiCoreV1SeccompProfile,Nothing}, _openapi_object["seccompProfile"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroups = haskey(_openapi_object, "supplementalGroups") ? _decode(Union{Absent,Union{Nothing,Vector{Int64}}}, _openapi_object["supplementalGroups"], _openapi_validate) : ABSENT + _openapi_field_supplementalgroupspolicy = haskey(_openapi_object, "supplementalGroupsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["supplementalGroupsPolicy"], _openapi_validate) : ABSENT + _openapi_field_sysctls = haskey(_openapi_object, "sysctls") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Sysctl}}}, _openapi_object["sysctls"], _openapi_validate) : ABSENT + _openapi_field_windowsoptions = haskey(_openapi_object, "windowsOptions") ? _decode(Union{Absent,IoK8sApiCoreV1WindowsSecurityContextOptions,Nothing}, _openapi_object["windowsOptions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appArmorProfile","fsGroup","fsGroupChangePolicy","runAsGroup","runAsNonRoot","runAsUser","seLinuxChangePolicy","seLinuxOptions","seccompProfile","supplementalGroups","supplementalGroupsPolicy","sysctls","windowsOptions") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSecurityContext(; apparmorprofile = _openapi_field_apparmorprofile, fsgroup = _openapi_field_fsgroup, fsgroupchangepolicy = _openapi_field_fsgroupchangepolicy, runasgroup = _openapi_field_runasgroup, runasnonroot = _openapi_field_runasnonroot, runasuser = _openapi_field_runasuser, selinuxchangepolicy = _openapi_field_selinuxchangepolicy, selinuxoptions = _openapi_field_selinuxoptions, seccompprofile = _openapi_field_seccompprofile, supplementalgroups = _openapi_field_supplementalgroups, supplementalgroupspolicy = _openapi_field_supplementalgroupspolicy, sysctls = _openapi_field_sysctls, windowsoptions = _openapi_field_windowsoptions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apparmorprofile isa Absent || (_openapi_output["appArmorProfile"] = _encode(_openapi_value.apparmorprofile)) + _openapi_value.fsgroup isa Absent || (_openapi_output["fsGroup"] = _encode(_openapi_value.fsgroup)) + _openapi_value.fsgroupchangepolicy isa Absent || (_openapi_output["fsGroupChangePolicy"] = _encode(_openapi_value.fsgroupchangepolicy)) + _openapi_value.runasgroup isa Absent || (_openapi_output["runAsGroup"] = _encode(_openapi_value.runasgroup)) + _openapi_value.runasnonroot isa Absent || (_openapi_output["runAsNonRoot"] = _encode(_openapi_value.runasnonroot)) + _openapi_value.runasuser isa Absent || (_openapi_output["runAsUser"] = _encode(_openapi_value.runasuser)) + _openapi_value.selinuxchangepolicy isa Absent || (_openapi_output["seLinuxChangePolicy"] = _encode(_openapi_value.selinuxchangepolicy)) + _openapi_value.selinuxoptions isa Absent || (_openapi_output["seLinuxOptions"] = _encode(_openapi_value.selinuxoptions)) + _openapi_value.seccompprofile isa Absent || (_openapi_output["seccompProfile"] = _encode(_openapi_value.seccompprofile)) + _openapi_value.supplementalgroups isa Absent || (_openapi_output["supplementalGroups"] = _encode(_openapi_value.supplementalgroups)) + _openapi_value.supplementalgroupspolicy isa Absent || (_openapi_output["supplementalGroupsPolicy"] = _encode(_openapi_value.supplementalgroupspolicy)) + _openapi_value.sysctls isa Absent || (_openapi_output["sysctls"] = _encode(_openapi_value.sysctls)) + _openapi_value.windowsoptions isa Absent || (_openapi_output["windowsOptions"] = _encode(_openapi_value.windowsoptions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSecurityContext"), _openapi_output, "encoding IoK8sApiCoreV1PodSecurityContext"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSecurityContext) + _openapi_output = Pair{String,Any}[] + _openapi_value.apparmorprofile isa Absent || push!(_openapi_output, "appArmorProfile" => _openapi_value.apparmorprofile) + _openapi_value.fsgroup isa Absent || push!(_openapi_output, "fsGroup" => _openapi_value.fsgroup) + _openapi_value.fsgroupchangepolicy isa Absent || push!(_openapi_output, "fsGroupChangePolicy" => _openapi_value.fsgroupchangepolicy) + _openapi_value.runasgroup isa Absent || push!(_openapi_output, "runAsGroup" => _openapi_value.runasgroup) + _openapi_value.runasnonroot isa Absent || push!(_openapi_output, "runAsNonRoot" => _openapi_value.runasnonroot) + _openapi_value.runasuser isa Absent || push!(_openapi_output, "runAsUser" => _openapi_value.runasuser) + _openapi_value.selinuxchangepolicy isa Absent || push!(_openapi_output, "seLinuxChangePolicy" => _openapi_value.selinuxchangepolicy) + _openapi_value.selinuxoptions isa Absent || push!(_openapi_output, "seLinuxOptions" => _openapi_value.selinuxoptions) + _openapi_value.seccompprofile isa Absent || push!(_openapi_output, "seccompProfile" => _openapi_value.seccompprofile) + _openapi_value.supplementalgroups isa Absent || push!(_openapi_output, "supplementalGroups" => _openapi_value.supplementalgroups) + _openapi_value.supplementalgroupspolicy isa Absent || push!(_openapi_output, "supplementalGroupsPolicy" => _openapi_value.supplementalgroupspolicy) + _openapi_value.sysctls isa Absent || push!(_openapi_output, "sysctls" => _openapi_value.sysctls) + _openapi_value.windowsoptions isa Absent || push!(_openapi_output, "windowsOptions" => _openapi_value.windowsoptions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Toleration + effect::Union{Absent,Nothing,String} = ABSENT + key::Union{Absent,Nothing,String} = ABSENT + operator::Union{Absent,Nothing,String} = ABSENT + tolerationseconds::Union{Absent,Int64,Nothing} = ABSENT + value::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Toleration}, value) = _decode(IoK8sApiCoreV1Toleration, value, true) +function _decode(::Type{IoK8sApiCoreV1Toleration}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_raw, "decoding IoK8sApiCoreV1Toleration"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Toleration") + _openapi_field_effect = haskey(_openapi_object, "effect") ? _decode(Union{Absent,Nothing,String}, _openapi_object["effect"], _openapi_validate) : ABSENT + _openapi_field_key = haskey(_openapi_object, "key") ? _decode(Union{Absent,Nothing,String}, _openapi_object["key"], _openapi_validate) : ABSENT + _openapi_field_operator = haskey(_openapi_object, "operator") ? _decode(Union{Absent,Nothing,String}, _openapi_object["operator"], _openapi_validate) : ABSENT + _openapi_field_tolerationseconds = haskey(_openapi_object, "tolerationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["tolerationSeconds"], _openapi_validate) : ABSENT + _openapi_field_value = haskey(_openapi_object, "value") ? _decode(Union{Absent,Nothing,String}, _openapi_object["value"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("effect","key","operator","tolerationSeconds","value") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Toleration(; effect = _openapi_field_effect, key = _openapi_field_key, operator = _openapi_field_operator, tolerationseconds = _openapi_field_tolerationseconds, value = _openapi_field_value, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.effect isa Absent || (_openapi_output["effect"] = _encode(_openapi_value.effect)) + _openapi_value.key isa Absent || (_openapi_output["key"] = _encode(_openapi_value.key)) + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.tolerationseconds isa Absent || (_openapi_output["tolerationSeconds"] = _encode(_openapi_value.tolerationseconds)) + _openapi_value.value isa Absent || (_openapi_output["value"] = _encode(_openapi_value.value)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Toleration"), _openapi_output, "encoding IoK8sApiCoreV1Toleration"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Toleration) + _openapi_output = Pair{String,Any}[] + _openapi_value.effect isa Absent || push!(_openapi_output, "effect" => _openapi_value.effect) + _openapi_value.key isa Absent || push!(_openapi_output, "key" => _openapi_value.key) + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.tolerationseconds isa Absent || push!(_openapi_output, "tolerationSeconds" => _openapi_value.tolerationseconds) + _openapi_value.value isa Absent || push!(_openapi_output, "value" => _openapi_value.value) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1TopologySpreadConstraint + labelselector::Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing} = ABSENT + matchlabelkeys::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + maxskew::Int32 + mindomains::Union{Absent,Int32,Nothing} = ABSENT + nodeaffinitypolicy::Union{Absent,Nothing,String} = ABSENT + nodetaintspolicy::Union{Absent,Nothing,String} = ABSENT + topologykey::String + whenunsatisfiable::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, value) = _decode(IoK8sApiCoreV1TopologySpreadConstraint, value, true) +function _decode(::Type{IoK8sApiCoreV1TopologySpreadConstraint}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_raw, "decoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1TopologySpreadConstraint") + _openapi_field_labelselector = haskey(_openapi_object, "labelSelector") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1LabelSelector,Nothing}, _openapi_object["labelSelector"], _openapi_validate) : ABSENT + _openapi_field_matchlabelkeys = haskey(_openapi_object, "matchLabelKeys") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["matchLabelKeys"], _openapi_validate) : ABSENT + _openapi_field_maxskew = _decode(Int32, _required(_openapi_object, "maxSkew", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_mindomains = haskey(_openapi_object, "minDomains") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minDomains"], _openapi_validate) : ABSENT + _openapi_field_nodeaffinitypolicy = haskey(_openapi_object, "nodeAffinityPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeAffinityPolicy"], _openapi_validate) : ABSENT + _openapi_field_nodetaintspolicy = haskey(_openapi_object, "nodeTaintsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeTaintsPolicy"], _openapi_validate) : ABSENT + _openapi_field_topologykey = _decode(String, _required(_openapi_object, "topologyKey", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_field_whenunsatisfiable = _decode(String, _required(_openapi_object, "whenUnsatisfiable", "IoK8sApiCoreV1TopologySpreadConstraint"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("labelSelector","matchLabelKeys","maxSkew","minDomains","nodeAffinityPolicy","nodeTaintsPolicy","topologyKey","whenUnsatisfiable") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1TopologySpreadConstraint(; labelselector = _openapi_field_labelselector, matchlabelkeys = _openapi_field_matchlabelkeys, maxskew = _openapi_field_maxskew, mindomains = _openapi_field_mindomains, nodeaffinitypolicy = _openapi_field_nodeaffinitypolicy, nodetaintspolicy = _openapi_field_nodetaintspolicy, topologykey = _openapi_field_topologykey, whenunsatisfiable = _openapi_field_whenunsatisfiable, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.labelselector isa Absent || (_openapi_output["labelSelector"] = _encode(_openapi_value.labelselector)) + _openapi_value.matchlabelkeys isa Absent || (_openapi_output["matchLabelKeys"] = _encode(_openapi_value.matchlabelkeys)) + _openapi_value.maxskew isa Absent || (_openapi_output["maxSkew"] = _encode(_openapi_value.maxskew)) + _openapi_value.mindomains isa Absent || (_openapi_output["minDomains"] = _encode(_openapi_value.mindomains)) + _openapi_value.nodeaffinitypolicy isa Absent || (_openapi_output["nodeAffinityPolicy"] = _encode(_openapi_value.nodeaffinitypolicy)) + _openapi_value.nodetaintspolicy isa Absent || (_openapi_output["nodeTaintsPolicy"] = _encode(_openapi_value.nodetaintspolicy)) + _openapi_value.topologykey isa Absent || (_openapi_output["topologyKey"] = _encode(_openapi_value.topologykey)) + _openapi_value.whenunsatisfiable isa Absent || (_openapi_output["whenUnsatisfiable"] = _encode(_openapi_value.whenunsatisfiable)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.TopologySpreadConstraint"), _openapi_output, "encoding IoK8sApiCoreV1TopologySpreadConstraint"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1TopologySpreadConstraint) + _openapi_output = Pair{String,Any}[] + _openapi_value.labelselector isa Absent || push!(_openapi_output, "labelSelector" => _openapi_value.labelselector) + _openapi_value.matchlabelkeys isa Absent || push!(_openapi_output, "matchLabelKeys" => _openapi_value.matchlabelkeys) + _openapi_value.maxskew isa Absent || push!(_openapi_output, "maxSkew" => _openapi_value.maxskew) + _openapi_value.mindomains isa Absent || push!(_openapi_output, "minDomains" => _openapi_value.mindomains) + _openapi_value.nodeaffinitypolicy isa Absent || push!(_openapi_output, "nodeAffinityPolicy" => _openapi_value.nodeaffinitypolicy) + _openapi_value.nodetaintspolicy isa Absent || push!(_openapi_output, "nodeTaintsPolicy" => _openapi_value.nodetaintspolicy) + _openapi_value.topologykey isa Absent || push!(_openapi_output, "topologyKey" => _openapi_value.topologykey) + _openapi_value.whenunsatisfiable isa Absent || push!(_openapi_output, "whenUnsatisfiable" => _openapi_value.whenunsatisfiable) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjectionUserAnnotations + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, value) = _decode(IoK8sApiCoreV1PodCertificateProjectionUserAnnotations, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjectionUserAnnotations}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjectionUserAnnotations") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjectionUserAnnotations(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection/properties/userAnnotations"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjectionUserAnnotations"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjectionUserAnnotations) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCertificateProjection + certificatechainpath::Union{Absent,Nothing,String} = ABSENT + credentialbundlepath::Union{Absent,Nothing,String} = ABSENT + keypath::Union{Absent,Nothing,String} = ABSENT + keytype::String + maxexpirationseconds::Union{Absent,Int32,Nothing} = ABSENT + signername::String + userannotations::Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, value) = _decode(IoK8sApiCoreV1PodCertificateProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCertificateProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_raw, "decoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCertificateProjection") + _openapi_field_certificatechainpath = haskey(_openapi_object, "certificateChainPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["certificateChainPath"], _openapi_validate) : ABSENT + _openapi_field_credentialbundlepath = haskey(_openapi_object, "credentialBundlePath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["credentialBundlePath"], _openapi_validate) : ABSENT + _openapi_field_keypath = haskey(_openapi_object, "keyPath") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyPath"], _openapi_validate) : ABSENT + _openapi_field_keytype = _decode(String, _required(_openapi_object, "keyType", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_maxexpirationseconds = haskey(_openapi_object, "maxExpirationSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["maxExpirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_signername = _decode(String, _required(_openapi_object, "signerName", "IoK8sApiCoreV1PodCertificateProjection"), _openapi_validate) + _openapi_field_userannotations = haskey(_openapi_object, "userAnnotations") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjectionUserAnnotations,Nothing}, _openapi_object["userAnnotations"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("certificateChainPath","credentialBundlePath","keyPath","keyType","maxExpirationSeconds","signerName","userAnnotations") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCertificateProjection(; certificatechainpath = _openapi_field_certificatechainpath, credentialbundlepath = _openapi_field_credentialbundlepath, keypath = _openapi_field_keypath, keytype = _openapi_field_keytype, maxexpirationseconds = _openapi_field_maxexpirationseconds, signername = _openapi_field_signername, userannotations = _openapi_field_userannotations, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.certificatechainpath isa Absent || (_openapi_output["certificateChainPath"] = _encode(_openapi_value.certificatechainpath)) + _openapi_value.credentialbundlepath isa Absent || (_openapi_output["credentialBundlePath"] = _encode(_openapi_value.credentialbundlepath)) + _openapi_value.keypath isa Absent || (_openapi_output["keyPath"] = _encode(_openapi_value.keypath)) + _openapi_value.keytype isa Absent || (_openapi_output["keyType"] = _encode(_openapi_value.keytype)) + _openapi_value.maxexpirationseconds isa Absent || (_openapi_output["maxExpirationSeconds"] = _encode(_openapi_value.maxexpirationseconds)) + _openapi_value.signername isa Absent || (_openapi_output["signerName"] = _encode(_openapi_value.signername)) + _openapi_value.userannotations isa Absent || (_openapi_output["userAnnotations"] = _encode(_openapi_value.userannotations)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCertificateProjection"), _openapi_output, "encoding IoK8sApiCoreV1PodCertificateProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCertificateProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.certificatechainpath isa Absent || push!(_openapi_output, "certificateChainPath" => _openapi_value.certificatechainpath) + _openapi_value.credentialbundlepath isa Absent || push!(_openapi_output, "credentialBundlePath" => _openapi_value.credentialbundlepath) + _openapi_value.keypath isa Absent || push!(_openapi_output, "keyPath" => _openapi_value.keypath) + _openapi_value.keytype isa Absent || push!(_openapi_output, "keyType" => _openapi_value.keytype) + _openapi_value.maxexpirationseconds isa Absent || push!(_openapi_output, "maxExpirationSeconds" => _openapi_value.maxexpirationseconds) + _openapi_value.signername isa Absent || push!(_openapi_output, "signerName" => _openapi_value.signername) + _openapi_value.userannotations isa Absent || push!(_openapi_output, "userAnnotations" => _openapi_value.userannotations) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretProjection + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretProjection}, value) = _decode(IoK8sApiCoreV1SecretProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_raw, "decoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretProjection") + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("items","name","optional") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretProjection(; items = _openapi_field_items, name = _openapi_field_name, optional = _openapi_field_optional, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretProjection"), _openapi_output, "encoding IoK8sApiCoreV1SecretProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceAccountTokenProjection + audience::Union{Absent,Nothing,String} = ABSENT + expirationseconds::Union{Absent,Int64,Nothing} = ABSENT + path::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, value) = _decode(IoK8sApiCoreV1ServiceAccountTokenProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceAccountTokenProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceAccountTokenProjection") + _openapi_field_audience = haskey(_openapi_object, "audience") ? _decode(Union{Absent,Nothing,String}, _openapi_object["audience"], _openapi_validate) : ABSENT + _openapi_field_expirationseconds = haskey(_openapi_object, "expirationSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["expirationSeconds"], _openapi_validate) : ABSENT + _openapi_field_path = _decode(String, _required(_openapi_object, "path", "IoK8sApiCoreV1ServiceAccountTokenProjection"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("audience","expirationSeconds","path") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceAccountTokenProjection(; audience = _openapi_field_audience, expirationseconds = _openapi_field_expirationseconds, path = _openapi_field_path, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.audience isa Absent || (_openapi_output["audience"] = _encode(_openapi_value.audience)) + _openapi_value.expirationseconds isa Absent || (_openapi_output["expirationSeconds"] = _encode(_openapi_value.expirationseconds)) + _openapi_value.path isa Absent || (_openapi_output["path"] = _encode(_openapi_value.path)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountTokenProjection"), _openapi_output, "encoding IoK8sApiCoreV1ServiceAccountTokenProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceAccountTokenProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.audience isa Absent || push!(_openapi_output, "audience" => _openapi_value.audience) + _openapi_value.expirationseconds isa Absent || push!(_openapi_output, "expirationSeconds" => _openapi_value.expirationseconds) + _openapi_value.path isa Absent || push!(_openapi_output, "path" => _openapi_value.path) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1VolumeProjection + clustertrustbundle::Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing} = ABSENT + podcertificate::Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing} = ABSENT + serviceaccounttoken::Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1VolumeProjection}, value) = _decode(IoK8sApiCoreV1VolumeProjection, value, true) +function _decode(::Type{IoK8sApiCoreV1VolumeProjection}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_raw, "decoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1VolumeProjection") + _openapi_field_clustertrustbundle = haskey(_openapi_object, "clusterTrustBundle") ? _decode(Union{Absent,IoK8sApiCoreV1ClusterTrustBundleProjection,Nothing}, _openapi_object["clusterTrustBundle"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapProjection,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIProjection,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_podcertificate = haskey(_openapi_object, "podCertificate") ? _decode(Union{Absent,IoK8sApiCoreV1PodCertificateProjection,Nothing}, _openapi_object["podCertificate"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretProjection,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_serviceaccounttoken = haskey(_openapi_object, "serviceAccountToken") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceAccountTokenProjection,Nothing}, _openapi_object["serviceAccountToken"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clusterTrustBundle","configMap","downwardAPI","podCertificate","secret","serviceAccountToken") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1VolumeProjection(; clustertrustbundle = _openapi_field_clustertrustbundle, configmap = _openapi_field_configmap, downwardapi = _openapi_field_downwardapi, podcertificate = _openapi_field_podcertificate, secret = _openapi_field_secret, serviceaccounttoken = _openapi_field_serviceaccounttoken, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clustertrustbundle isa Absent || (_openapi_output["clusterTrustBundle"] = _encode(_openapi_value.clustertrustbundle)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.podcertificate isa Absent || (_openapi_output["podCertificate"] = _encode(_openapi_value.podcertificate)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.serviceaccounttoken isa Absent || (_openapi_output["serviceAccountToken"] = _encode(_openapi_value.serviceaccounttoken)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.VolumeProjection"), _openapi_output, "encoding IoK8sApiCoreV1VolumeProjection"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1VolumeProjection) + _openapi_output = Pair{String,Any}[] + _openapi_value.clustertrustbundle isa Absent || push!(_openapi_output, "clusterTrustBundle" => _openapi_value.clustertrustbundle) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.podcertificate isa Absent || push!(_openapi_output, "podCertificate" => _openapi_value.podcertificate) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.serviceaccounttoken isa Absent || push!(_openapi_output, "serviceAccountToken" => _openapi_value.serviceaccounttoken) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ProjectedVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + sources::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, value) = _decode(IoK8sApiCoreV1ProjectedVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ProjectedVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ProjectedVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_sources = haskey(_openapi_object, "sources") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1VolumeProjection}}}, _openapi_object["sources"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","sources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ProjectedVolumeSource(; defaultmode = _openapi_field_defaultmode, sources = _openapi_field_sources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.sources isa Absent || (_openapi_output["sources"] = _encode(_openapi_value.sources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ProjectedVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ProjectedVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ProjectedVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.sources isa Absent || push!(_openapi_output, "sources" => _openapi_value.sources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1RBDVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + image::String + keyring::Union{Absent,Nothing,String} = ABSENT + monitors::Union{Nothing,Vector{String}} + pool::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + user::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, value) = _decode(IoK8sApiCoreV1RBDVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1RBDVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1RBDVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_image = _decode(String, _required(_openapi_object, "image", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_keyring = haskey(_openapi_object, "keyring") ? _decode(Union{Absent,Nothing,String}, _openapi_object["keyring"], _openapi_validate) : ABSENT + _openapi_field_monitors = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "monitors", "IoK8sApiCoreV1RBDVolumeSource"), _openapi_validate) + _openapi_field_pool = haskey(_openapi_object, "pool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["pool"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_user = haskey(_openapi_object, "user") ? _decode(Union{Absent,Nothing,String}, _openapi_object["user"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","image","keyring","monitors","pool","readOnly","secretRef","user") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1RBDVolumeSource(; fstype = _openapi_field_fstype, image = _openapi_field_image, keyring = _openapi_field_keyring, monitors = _openapi_field_monitors, pool = _openapi_field_pool, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, user = _openapi_field_user, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.keyring isa Absent || (_openapi_output["keyring"] = _encode(_openapi_value.keyring)) + _openapi_value.monitors isa Absent || (_openapi_output["monitors"] = _encode(_openapi_value.monitors)) + _openapi_value.pool isa Absent || (_openapi_output["pool"] = _encode(_openapi_value.pool)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.user isa Absent || (_openapi_output["user"] = _encode(_openapi_value.user)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.RBDVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1RBDVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1RBDVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.keyring isa Absent || push!(_openapi_output, "keyring" => _openapi_value.keyring) + _openapi_value.monitors isa Absent || push!(_openapi_output, "monitors" => _openapi_value.monitors) + _openapi_value.pool isa Absent || push!(_openapi_output, "pool" => _openapi_value.pool) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.user isa Absent || push!(_openapi_output, "user" => _openapi_value.user) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScaleIOVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + gateway::String + protectiondomain::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::IoK8sApiCoreV1LocalObjectReference + sslenabled::Union{Absent,Bool,Nothing} = ABSENT + storagemode::Union{Absent,Nothing,String} = ABSENT + storagepool::Union{Absent,Nothing,String} = ABSENT + system::String + volumename::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, value) = _decode(IoK8sApiCoreV1ScaleIOVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1ScaleIOVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScaleIOVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_gateway = _decode(String, _required(_openapi_object, "gateway", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_protectiondomain = haskey(_openapi_object, "protectionDomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protectionDomain"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = _decode(IoK8sApiCoreV1LocalObjectReference, _required(_openapi_object, "secretRef", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_sslenabled = haskey(_openapi_object, "sslEnabled") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["sslEnabled"], _openapi_validate) : ABSENT + _openapi_field_storagemode = haskey(_openapi_object, "storageMode") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageMode"], _openapi_validate) : ABSENT + _openapi_field_storagepool = haskey(_openapi_object, "storagePool") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storagePool"], _openapi_validate) : ABSENT + _openapi_field_system = _decode(String, _required(_openapi_object, "system", "IoK8sApiCoreV1ScaleIOVolumeSource"), _openapi_validate) + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","gateway","protectionDomain","readOnly","secretRef","sslEnabled","storageMode","storagePool","system","volumeName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScaleIOVolumeSource(; fstype = _openapi_field_fstype, gateway = _openapi_field_gateway, protectiondomain = _openapi_field_protectiondomain, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, sslenabled = _openapi_field_sslenabled, storagemode = _openapi_field_storagemode, storagepool = _openapi_field_storagepool, system = _openapi_field_system, volumename = _openapi_field_volumename, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.gateway isa Absent || (_openapi_output["gateway"] = _encode(_openapi_value.gateway)) + _openapi_value.protectiondomain isa Absent || (_openapi_output["protectionDomain"] = _encode(_openapi_value.protectiondomain)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.sslenabled isa Absent || (_openapi_output["sslEnabled"] = _encode(_openapi_value.sslenabled)) + _openapi_value.storagemode isa Absent || (_openapi_output["storageMode"] = _encode(_openapi_value.storagemode)) + _openapi_value.storagepool isa Absent || (_openapi_output["storagePool"] = _encode(_openapi_value.storagepool)) + _openapi_value.system isa Absent || (_openapi_output["system"] = _encode(_openapi_value.system)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1ScaleIOVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScaleIOVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.gateway isa Absent || push!(_openapi_output, "gateway" => _openapi_value.gateway) + _openapi_value.protectiondomain isa Absent || push!(_openapi_output, "protectionDomain" => _openapi_value.protectiondomain) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.sslenabled isa Absent || push!(_openapi_output, "sslEnabled" => _openapi_value.sslenabled) + _openapi_value.storagemode isa Absent || push!(_openapi_output, "storageMode" => _openapi_value.storagemode) + _openapi_value.storagepool isa Absent || push!(_openapi_output, "storagePool" => _openapi_value.storagepool) + _openapi_value.system isa Absent || push!(_openapi_output, "system" => _openapi_value.system) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretVolumeSource + defaultmode::Union{Absent,Int32,Nothing} = ABSENT + items::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}} = ABSENT + optional::Union{Absent,Bool,Nothing} = ABSENT + secretname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, value) = _decode(IoK8sApiCoreV1SecretVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretVolumeSource") + _openapi_field_defaultmode = haskey(_openapi_object, "defaultMode") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["defaultMode"], _openapi_validate) : ABSENT + _openapi_field_items = haskey(_openapi_object, "items") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1KeyToPath}}}, _openapi_object["items"], _openapi_validate) : ABSENT + _openapi_field_optional = haskey(_openapi_object, "optional") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["optional"], _openapi_validate) : ABSENT + _openapi_field_secretname = haskey(_openapi_object, "secretName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["secretName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("defaultMode","items","optional","secretName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretVolumeSource(; defaultmode = _openapi_field_defaultmode, items = _openapi_field_items, optional = _openapi_field_optional, secretname = _openapi_field_secretname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.defaultmode isa Absent || (_openapi_output["defaultMode"] = _encode(_openapi_value.defaultmode)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.optional isa Absent || (_openapi_output["optional"] = _encode(_openapi_value.optional)) + _openapi_value.secretname isa Absent || (_openapi_output["secretName"] = _encode(_openapi_value.secretname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1SecretVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.defaultmode isa Absent || push!(_openapi_output, "defaultMode" => _openapi_value.defaultmode) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.optional isa Absent || push!(_openapi_output, "optional" => _openapi_value.optional) + _openapi_value.secretname isa Absent || push!(_openapi_output, "secretName" => _openapi_value.secretname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1StorageOSVolumeSource + fstype::Union{Absent,Nothing,String} = ABSENT + readonly::Union{Absent,Bool,Nothing} = ABSENT + secretref::Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing} = ABSENT + volumename::Union{Absent,Nothing,String} = ABSENT + volumenamespace::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, value) = _decode(IoK8sApiCoreV1StorageOSVolumeSource, value, true) +function _decode(::Type{IoK8sApiCoreV1StorageOSVolumeSource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_raw, "decoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1StorageOSVolumeSource") + _openapi_field_fstype = haskey(_openapi_object, "fsType") ? _decode(Union{Absent,Nothing,String}, _openapi_object["fsType"], _openapi_validate) : ABSENT + _openapi_field_readonly = haskey(_openapi_object, "readOnly") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["readOnly"], _openapi_validate) : ABSENT + _openapi_field_secretref = haskey(_openapi_object, "secretRef") ? _decode(Union{Absent,IoK8sApiCoreV1LocalObjectReference,Nothing}, _openapi_object["secretRef"], _openapi_validate) : ABSENT + _openapi_field_volumename = haskey(_openapi_object, "volumeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeName"], _openapi_validate) : ABSENT + _openapi_field_volumenamespace = haskey(_openapi_object, "volumeNamespace") ? _decode(Union{Absent,Nothing,String}, _openapi_object["volumeNamespace"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("fsType","readOnly","secretRef","volumeName","volumeNamespace") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1StorageOSVolumeSource(; fstype = _openapi_field_fstype, readonly = _openapi_field_readonly, secretref = _openapi_field_secretref, volumename = _openapi_field_volumename, volumenamespace = _openapi_field_volumenamespace, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.fstype isa Absent || (_openapi_output["fsType"] = _encode(_openapi_value.fstype)) + _openapi_value.readonly isa Absent || (_openapi_output["readOnly"] = _encode(_openapi_value.readonly)) + _openapi_value.secretref isa Absent || (_openapi_output["secretRef"] = _encode(_openapi_value.secretref)) + _openapi_value.volumename isa Absent || (_openapi_output["volumeName"] = _encode(_openapi_value.volumename)) + _openapi_value.volumenamespace isa Absent || (_openapi_output["volumeNamespace"] = _encode(_openapi_value.volumenamespace)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.StorageOSVolumeSource"), _openapi_output, "encoding IoK8sApiCoreV1StorageOSVolumeSource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1StorageOSVolumeSource) + _openapi_output = Pair{String,Any}[] + _openapi_value.fstype isa Absent || push!(_openapi_output, "fsType" => _openapi_value.fstype) + _openapi_value.readonly isa Absent || push!(_openapi_output, "readOnly" => _openapi_value.readonly) + _openapi_value.secretref isa Absent || push!(_openapi_output, "secretRef" => _openapi_value.secretref) + _openapi_value.volumename isa Absent || push!(_openapi_output, "volumeName" => _openapi_value.volumename) + _openapi_value.volumenamespace isa Absent || push!(_openapi_output, "volumeNamespace" => _openapi_value.volumenamespace) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Volume + awselasticblockstore::Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing} = ABSENT + azuredisk::Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing} = ABSENT + azurefile::Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing} = ABSENT + cephfs::Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing} = ABSENT + cinder::Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing} = ABSENT + configmap::Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing} = ABSENT + csi::Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing} = ABSENT + downwardapi::Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing} = ABSENT + emptydir::Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing} = ABSENT + ephemeral::Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing} = ABSENT + fc::Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing} = ABSENT + flexvolume::Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing} = ABSENT + flocker::Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing} = ABSENT + gcepersistentdisk::Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing} = ABSENT + gitrepo::Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing} = ABSENT + glusterfs::Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing} = ABSENT + hostpath::Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing} = ABSENT + image::Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing} = ABSENT + iscsi::Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing} = ABSENT + name::String + nfs::Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing} = ABSENT + persistentvolumeclaim::Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing} = ABSENT + photonpersistentdisk::Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing} = ABSENT + portworxvolume::Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing} = ABSENT + projected::Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing} = ABSENT + quobyte::Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing} = ABSENT + rbd::Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing} = ABSENT + scaleio::Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing} = ABSENT + secret::Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing} = ABSENT + storageos::Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing} = ABSENT + vspherevolume::Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Volume}, value) = _decode(IoK8sApiCoreV1Volume, value, true) +function _decode(::Type{IoK8sApiCoreV1Volume}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_raw, "decoding IoK8sApiCoreV1Volume"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Volume") + _openapi_field_awselasticblockstore = haskey(_openapi_object, "awsElasticBlockStore") ? _decode(Union{Absent,IoK8sApiCoreV1AWSElasticBlockStoreVolumeSource,Nothing}, _openapi_object["awsElasticBlockStore"], _openapi_validate) : ABSENT + _openapi_field_azuredisk = haskey(_openapi_object, "azureDisk") ? _decode(Union{Absent,IoK8sApiCoreV1AzureDiskVolumeSource,Nothing}, _openapi_object["azureDisk"], _openapi_validate) : ABSENT + _openapi_field_azurefile = haskey(_openapi_object, "azureFile") ? _decode(Union{Absent,IoK8sApiCoreV1AzureFileVolumeSource,Nothing}, _openapi_object["azureFile"], _openapi_validate) : ABSENT + _openapi_field_cephfs = haskey(_openapi_object, "cephfs") ? _decode(Union{Absent,IoK8sApiCoreV1CephFSVolumeSource,Nothing}, _openapi_object["cephfs"], _openapi_validate) : ABSENT + _openapi_field_cinder = haskey(_openapi_object, "cinder") ? _decode(Union{Absent,IoK8sApiCoreV1CinderVolumeSource,Nothing}, _openapi_object["cinder"], _openapi_validate) : ABSENT + _openapi_field_configmap = haskey(_openapi_object, "configMap") ? _decode(Union{Absent,IoK8sApiCoreV1ConfigMapVolumeSource,Nothing}, _openapi_object["configMap"], _openapi_validate) : ABSENT + _openapi_field_csi = haskey(_openapi_object, "csi") ? _decode(Union{Absent,IoK8sApiCoreV1CSIVolumeSource,Nothing}, _openapi_object["csi"], _openapi_validate) : ABSENT + _openapi_field_downwardapi = haskey(_openapi_object, "downwardAPI") ? _decode(Union{Absent,IoK8sApiCoreV1DownwardAPIVolumeSource,Nothing}, _openapi_object["downwardAPI"], _openapi_validate) : ABSENT + _openapi_field_emptydir = haskey(_openapi_object, "emptyDir") ? _decode(Union{Absent,IoK8sApiCoreV1EmptyDirVolumeSource,Nothing}, _openapi_object["emptyDir"], _openapi_validate) : ABSENT + _openapi_field_ephemeral = haskey(_openapi_object, "ephemeral") ? _decode(Union{Absent,IoK8sApiCoreV1EphemeralVolumeSource,Nothing}, _openapi_object["ephemeral"], _openapi_validate) : ABSENT + _openapi_field_fc = haskey(_openapi_object, "fc") ? _decode(Union{Absent,IoK8sApiCoreV1FCVolumeSource,Nothing}, _openapi_object["fc"], _openapi_validate) : ABSENT + _openapi_field_flexvolume = haskey(_openapi_object, "flexVolume") ? _decode(Union{Absent,IoK8sApiCoreV1FlexVolumeSource,Nothing}, _openapi_object["flexVolume"], _openapi_validate) : ABSENT + _openapi_field_flocker = haskey(_openapi_object, "flocker") ? _decode(Union{Absent,IoK8sApiCoreV1FlockerVolumeSource,Nothing}, _openapi_object["flocker"], _openapi_validate) : ABSENT + _openapi_field_gcepersistentdisk = haskey(_openapi_object, "gcePersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1GCEPersistentDiskVolumeSource,Nothing}, _openapi_object["gcePersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_gitrepo = haskey(_openapi_object, "gitRepo") ? _decode(Union{Absent,IoK8sApiCoreV1GitRepoVolumeSource,Nothing}, _openapi_object["gitRepo"], _openapi_validate) : ABSENT + _openapi_field_glusterfs = haskey(_openapi_object, "glusterfs") ? _decode(Union{Absent,IoK8sApiCoreV1GlusterfsVolumeSource,Nothing}, _openapi_object["glusterfs"], _openapi_validate) : ABSENT + _openapi_field_hostpath = haskey(_openapi_object, "hostPath") ? _decode(Union{Absent,IoK8sApiCoreV1HostPathVolumeSource,Nothing}, _openapi_object["hostPath"], _openapi_validate) : ABSENT + _openapi_field_image = haskey(_openapi_object, "image") ? _decode(Union{Absent,IoK8sApiCoreV1ImageVolumeSource,Nothing}, _openapi_object["image"], _openapi_validate) : ABSENT + _openapi_field_iscsi = haskey(_openapi_object, "iscsi") ? _decode(Union{Absent,IoK8sApiCoreV1ISCSIVolumeSource,Nothing}, _openapi_object["iscsi"], _openapi_validate) : ABSENT + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1Volume"), _openapi_validate) + _openapi_field_nfs = haskey(_openapi_object, "nfs") ? _decode(Union{Absent,IoK8sApiCoreV1NFSVolumeSource,Nothing}, _openapi_object["nfs"], _openapi_validate) : ABSENT + _openapi_field_persistentvolumeclaim = haskey(_openapi_object, "persistentVolumeClaim") ? _decode(Union{Absent,IoK8sApiCoreV1PersistentVolumeClaimVolumeSource,Nothing}, _openapi_object["persistentVolumeClaim"], _openapi_validate) : ABSENT + _openapi_field_photonpersistentdisk = haskey(_openapi_object, "photonPersistentDisk") ? _decode(Union{Absent,IoK8sApiCoreV1PhotonPersistentDiskVolumeSource,Nothing}, _openapi_object["photonPersistentDisk"], _openapi_validate) : ABSENT + _openapi_field_portworxvolume = haskey(_openapi_object, "portworxVolume") ? _decode(Union{Absent,IoK8sApiCoreV1PortworxVolumeSource,Nothing}, _openapi_object["portworxVolume"], _openapi_validate) : ABSENT + _openapi_field_projected = haskey(_openapi_object, "projected") ? _decode(Union{Absent,IoK8sApiCoreV1ProjectedVolumeSource,Nothing}, _openapi_object["projected"], _openapi_validate) : ABSENT + _openapi_field_quobyte = haskey(_openapi_object, "quobyte") ? _decode(Union{Absent,IoK8sApiCoreV1QuobyteVolumeSource,Nothing}, _openapi_object["quobyte"], _openapi_validate) : ABSENT + _openapi_field_rbd = haskey(_openapi_object, "rbd") ? _decode(Union{Absent,IoK8sApiCoreV1RBDVolumeSource,Nothing}, _openapi_object["rbd"], _openapi_validate) : ABSENT + _openapi_field_scaleio = haskey(_openapi_object, "scaleIO") ? _decode(Union{Absent,IoK8sApiCoreV1ScaleIOVolumeSource,Nothing}, _openapi_object["scaleIO"], _openapi_validate) : ABSENT + _openapi_field_secret = haskey(_openapi_object, "secret") ? _decode(Union{Absent,IoK8sApiCoreV1SecretVolumeSource,Nothing}, _openapi_object["secret"], _openapi_validate) : ABSENT + _openapi_field_storageos = haskey(_openapi_object, "storageos") ? _decode(Union{Absent,IoK8sApiCoreV1StorageOSVolumeSource,Nothing}, _openapi_object["storageos"], _openapi_validate) : ABSENT + _openapi_field_vspherevolume = haskey(_openapi_object, "vsphereVolume") ? _decode(Union{Absent,IoK8sApiCoreV1VsphereVirtualDiskVolumeSource,Nothing}, _openapi_object["vsphereVolume"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("awsElasticBlockStore","azureDisk","azureFile","cephfs","cinder","configMap","csi","downwardAPI","emptyDir","ephemeral","fc","flexVolume","flocker","gcePersistentDisk","gitRepo","glusterfs","hostPath","image","iscsi","name","nfs","persistentVolumeClaim","photonPersistentDisk","portworxVolume","projected","quobyte","rbd","scaleIO","secret","storageos","vsphereVolume") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Volume(; awselasticblockstore = _openapi_field_awselasticblockstore, azuredisk = _openapi_field_azuredisk, azurefile = _openapi_field_azurefile, cephfs = _openapi_field_cephfs, cinder = _openapi_field_cinder, configmap = _openapi_field_configmap, csi = _openapi_field_csi, downwardapi = _openapi_field_downwardapi, emptydir = _openapi_field_emptydir, ephemeral = _openapi_field_ephemeral, fc = _openapi_field_fc, flexvolume = _openapi_field_flexvolume, flocker = _openapi_field_flocker, gcepersistentdisk = _openapi_field_gcepersistentdisk, gitrepo = _openapi_field_gitrepo, glusterfs = _openapi_field_glusterfs, hostpath = _openapi_field_hostpath, image = _openapi_field_image, iscsi = _openapi_field_iscsi, name = _openapi_field_name, nfs = _openapi_field_nfs, persistentvolumeclaim = _openapi_field_persistentvolumeclaim, photonpersistentdisk = _openapi_field_photonpersistentdisk, portworxvolume = _openapi_field_portworxvolume, projected = _openapi_field_projected, quobyte = _openapi_field_quobyte, rbd = _openapi_field_rbd, scaleio = _openapi_field_scaleio, secret = _openapi_field_secret, storageos = _openapi_field_storageos, vspherevolume = _openapi_field_vspherevolume, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.awselasticblockstore isa Absent || (_openapi_output["awsElasticBlockStore"] = _encode(_openapi_value.awselasticblockstore)) + _openapi_value.azuredisk isa Absent || (_openapi_output["azureDisk"] = _encode(_openapi_value.azuredisk)) + _openapi_value.azurefile isa Absent || (_openapi_output["azureFile"] = _encode(_openapi_value.azurefile)) + _openapi_value.cephfs isa Absent || (_openapi_output["cephfs"] = _encode(_openapi_value.cephfs)) + _openapi_value.cinder isa Absent || (_openapi_output["cinder"] = _encode(_openapi_value.cinder)) + _openapi_value.configmap isa Absent || (_openapi_output["configMap"] = _encode(_openapi_value.configmap)) + _openapi_value.csi isa Absent || (_openapi_output["csi"] = _encode(_openapi_value.csi)) + _openapi_value.downwardapi isa Absent || (_openapi_output["downwardAPI"] = _encode(_openapi_value.downwardapi)) + _openapi_value.emptydir isa Absent || (_openapi_output["emptyDir"] = _encode(_openapi_value.emptydir)) + _openapi_value.ephemeral isa Absent || (_openapi_output["ephemeral"] = _encode(_openapi_value.ephemeral)) + _openapi_value.fc isa Absent || (_openapi_output["fc"] = _encode(_openapi_value.fc)) + _openapi_value.flexvolume isa Absent || (_openapi_output["flexVolume"] = _encode(_openapi_value.flexvolume)) + _openapi_value.flocker isa Absent || (_openapi_output["flocker"] = _encode(_openapi_value.flocker)) + _openapi_value.gcepersistentdisk isa Absent || (_openapi_output["gcePersistentDisk"] = _encode(_openapi_value.gcepersistentdisk)) + _openapi_value.gitrepo isa Absent || (_openapi_output["gitRepo"] = _encode(_openapi_value.gitrepo)) + _openapi_value.glusterfs isa Absent || (_openapi_output["glusterfs"] = _encode(_openapi_value.glusterfs)) + _openapi_value.hostpath isa Absent || (_openapi_output["hostPath"] = _encode(_openapi_value.hostpath)) + _openapi_value.image isa Absent || (_openapi_output["image"] = _encode(_openapi_value.image)) + _openapi_value.iscsi isa Absent || (_openapi_output["iscsi"] = _encode(_openapi_value.iscsi)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.nfs isa Absent || (_openapi_output["nfs"] = _encode(_openapi_value.nfs)) + _openapi_value.persistentvolumeclaim isa Absent || (_openapi_output["persistentVolumeClaim"] = _encode(_openapi_value.persistentvolumeclaim)) + _openapi_value.photonpersistentdisk isa Absent || (_openapi_output["photonPersistentDisk"] = _encode(_openapi_value.photonpersistentdisk)) + _openapi_value.portworxvolume isa Absent || (_openapi_output["portworxVolume"] = _encode(_openapi_value.portworxvolume)) + _openapi_value.projected isa Absent || (_openapi_output["projected"] = _encode(_openapi_value.projected)) + _openapi_value.quobyte isa Absent || (_openapi_output["quobyte"] = _encode(_openapi_value.quobyte)) + _openapi_value.rbd isa Absent || (_openapi_output["rbd"] = _encode(_openapi_value.rbd)) + _openapi_value.scaleio isa Absent || (_openapi_output["scaleIO"] = _encode(_openapi_value.scaleio)) + _openapi_value.secret isa Absent || (_openapi_output["secret"] = _encode(_openapi_value.secret)) + _openapi_value.storageos isa Absent || (_openapi_output["storageos"] = _encode(_openapi_value.storageos)) + _openapi_value.vspherevolume isa Absent || (_openapi_output["vsphereVolume"] = _encode(_openapi_value.vspherevolume)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Volume"), _openapi_output, "encoding IoK8sApiCoreV1Volume"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Volume) + _openapi_output = Pair{String,Any}[] + _openapi_value.awselasticblockstore isa Absent || push!(_openapi_output, "awsElasticBlockStore" => _openapi_value.awselasticblockstore) + _openapi_value.azuredisk isa Absent || push!(_openapi_output, "azureDisk" => _openapi_value.azuredisk) + _openapi_value.azurefile isa Absent || push!(_openapi_output, "azureFile" => _openapi_value.azurefile) + _openapi_value.cephfs isa Absent || push!(_openapi_output, "cephfs" => _openapi_value.cephfs) + _openapi_value.cinder isa Absent || push!(_openapi_output, "cinder" => _openapi_value.cinder) + _openapi_value.configmap isa Absent || push!(_openapi_output, "configMap" => _openapi_value.configmap) + _openapi_value.csi isa Absent || push!(_openapi_output, "csi" => _openapi_value.csi) + _openapi_value.downwardapi isa Absent || push!(_openapi_output, "downwardAPI" => _openapi_value.downwardapi) + _openapi_value.emptydir isa Absent || push!(_openapi_output, "emptyDir" => _openapi_value.emptydir) + _openapi_value.ephemeral isa Absent || push!(_openapi_output, "ephemeral" => _openapi_value.ephemeral) + _openapi_value.fc isa Absent || push!(_openapi_output, "fc" => _openapi_value.fc) + _openapi_value.flexvolume isa Absent || push!(_openapi_output, "flexVolume" => _openapi_value.flexvolume) + _openapi_value.flocker isa Absent || push!(_openapi_output, "flocker" => _openapi_value.flocker) + _openapi_value.gcepersistentdisk isa Absent || push!(_openapi_output, "gcePersistentDisk" => _openapi_value.gcepersistentdisk) + _openapi_value.gitrepo isa Absent || push!(_openapi_output, "gitRepo" => _openapi_value.gitrepo) + _openapi_value.glusterfs isa Absent || push!(_openapi_output, "glusterfs" => _openapi_value.glusterfs) + _openapi_value.hostpath isa Absent || push!(_openapi_output, "hostPath" => _openapi_value.hostpath) + _openapi_value.image isa Absent || push!(_openapi_output, "image" => _openapi_value.image) + _openapi_value.iscsi isa Absent || push!(_openapi_output, "iscsi" => _openapi_value.iscsi) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.nfs isa Absent || push!(_openapi_output, "nfs" => _openapi_value.nfs) + _openapi_value.persistentvolumeclaim isa Absent || push!(_openapi_output, "persistentVolumeClaim" => _openapi_value.persistentvolumeclaim) + _openapi_value.photonpersistentdisk isa Absent || push!(_openapi_output, "photonPersistentDisk" => _openapi_value.photonpersistentdisk) + _openapi_value.portworxvolume isa Absent || push!(_openapi_output, "portworxVolume" => _openapi_value.portworxvolume) + _openapi_value.projected isa Absent || push!(_openapi_output, "projected" => _openapi_value.projected) + _openapi_value.quobyte isa Absent || push!(_openapi_output, "quobyte" => _openapi_value.quobyte) + _openapi_value.rbd isa Absent || push!(_openapi_output, "rbd" => _openapi_value.rbd) + _openapi_value.scaleio isa Absent || push!(_openapi_output, "scaleIO" => _openapi_value.scaleio) + _openapi_value.secret isa Absent || push!(_openapi_output, "secret" => _openapi_value.secret) + _openapi_value.storageos isa Absent || push!(_openapi_output, "storageos" => _openapi_value.storageos) + _openapi_value.vspherevolume isa Absent || push!(_openapi_output, "vsphereVolume" => _openapi_value.vspherevolume) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1WorkloadReference + name::String + podgroup::String + podgroupreplicakey::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1WorkloadReference}, value) = _decode(IoK8sApiCoreV1WorkloadReference, value, true) +function _decode(::Type{IoK8sApiCoreV1WorkloadReference}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_raw, "decoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1WorkloadReference") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroup = _decode(String, _required(_openapi_object, "podGroup", "IoK8sApiCoreV1WorkloadReference"), _openapi_validate) + _openapi_field_podgroupreplicakey = haskey(_openapi_object, "podGroupReplicaKey") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podGroupReplicaKey"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","podGroup","podGroupReplicaKey") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1WorkloadReference(; name = _openapi_field_name, podgroup = _openapi_field_podgroup, podgroupreplicakey = _openapi_field_podgroupreplicakey, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.podgroup isa Absent || (_openapi_output["podGroup"] = _encode(_openapi_value.podgroup)) + _openapi_value.podgroupreplicakey isa Absent || (_openapi_output["podGroupReplicaKey"] = _encode(_openapi_value.podgroupreplicakey)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.WorkloadReference"), _openapi_output, "encoding IoK8sApiCoreV1WorkloadReference"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1WorkloadReference) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.podgroup isa Absent || push!(_openapi_output, "podGroup" => _openapi_value.podgroup) + _openapi_value.podgroupreplicakey isa Absent || push!(_openapi_output, "podGroupReplicaKey" => _openapi_value.podgroupreplicakey) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodSpec + activedeadlineseconds::Union{Absent,Int64,Nothing} = ABSENT + affinity::Union{Absent,IoK8sApiCoreV1Affinity,Nothing} = ABSENT + automountserviceaccounttoken::Union{Absent,Bool,Nothing} = ABSENT + containers::Union{Nothing,Vector{IoK8sApiCoreV1Container}} + dnsconfig::Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing} = ABSENT + dnspolicy::Union{Absent,Nothing,String} = ABSENT + enableservicelinks::Union{Absent,Bool,Nothing} = ABSENT + ephemeralcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}} = ABSENT + hostaliases::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}} = ABSENT + hostipc::Union{Absent,Bool,Nothing} = ABSENT + hostnetwork::Union{Absent,Bool,Nothing} = ABSENT + hostpid::Union{Absent,Bool,Nothing} = ABSENT + hostusers::Union{Absent,Bool,Nothing} = ABSENT + hostname::Union{Absent,Nothing,String} = ABSENT + hostnameoverride::Union{Absent,Nothing,String} = ABSENT + imagepullsecrets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}} = ABSENT + initcontainers::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}} = ABSENT + nodename::Union{Absent,Nothing,String} = ABSENT + nodeselector::Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing} = ABSENT + os::Union{Absent,IoK8sApiCoreV1PodOS,Nothing} = ABSENT + overhead::Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing} = ABSENT + preemptionpolicy::Union{Absent,Nothing,String} = ABSENT + priority::Union{Absent,Int32,Nothing} = ABSENT + priorityclassname::Union{Absent,Nothing,String} = ABSENT + readinessgates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}} = ABSENT + resourceclaims::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + restartpolicy::Union{Absent,Nothing,String} = ABSENT + runtimeclassname::Union{Absent,Nothing,String} = ABSENT + schedulername::Union{Absent,Nothing,String} = ABSENT + schedulinggates::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}} = ABSENT + securitycontext::Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing} = ABSENT + serviceaccount::Union{Absent,Nothing,String} = ABSENT + serviceaccountname::Union{Absent,Nothing,String} = ABSENT + sethostnameasfqdn::Union{Absent,Bool,Nothing} = ABSENT + shareprocessnamespace::Union{Absent,Bool,Nothing} = ABSENT + subdomain::Union{Absent,Nothing,String} = ABSENT + terminationgraceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + tolerations::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}} = ABSENT + topologyspreadconstraints::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}} = ABSENT + volumes::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}} = ABSENT + workloadref::Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodSpec}, value) = _decode(IoK8sApiCoreV1PodSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodSpec") + _openapi_field_activedeadlineseconds = haskey(_openapi_object, "activeDeadlineSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["activeDeadlineSeconds"], _openapi_validate) : ABSENT + _openapi_field_affinity = haskey(_openapi_object, "affinity") ? _decode(Union{Absent,IoK8sApiCoreV1Affinity,Nothing}, _openapi_object["affinity"], _openapi_validate) : ABSENT + _openapi_field_automountserviceaccounttoken = haskey(_openapi_object, "automountServiceAccountToken") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["automountServiceAccountToken"], _openapi_validate) : ABSENT + _openapi_field_containers = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Container}}, _required(_openapi_object, "containers", "IoK8sApiCoreV1PodSpec"), _openapi_validate) + _openapi_field_dnsconfig = haskey(_openapi_object, "dnsConfig") ? _decode(Union{Absent,IoK8sApiCoreV1PodDNSConfig,Nothing}, _openapi_object["dnsConfig"], _openapi_validate) : ABSENT + _openapi_field_dnspolicy = haskey(_openapi_object, "dnsPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["dnsPolicy"], _openapi_validate) : ABSENT + _openapi_field_enableservicelinks = haskey(_openapi_object, "enableServiceLinks") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["enableServiceLinks"], _openapi_validate) : ABSENT + _openapi_field_ephemeralcontainers = haskey(_openapi_object, "ephemeralContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1EphemeralContainer}}}, _openapi_object["ephemeralContainers"], _openapi_validate) : ABSENT + _openapi_field_hostaliases = haskey(_openapi_object, "hostAliases") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostAlias}}}, _openapi_object["hostAliases"], _openapi_validate) : ABSENT + _openapi_field_hostipc = haskey(_openapi_object, "hostIPC") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostIPC"], _openapi_validate) : ABSENT + _openapi_field_hostnetwork = haskey(_openapi_object, "hostNetwork") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostNetwork"], _openapi_validate) : ABSENT + _openapi_field_hostpid = haskey(_openapi_object, "hostPID") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostPID"], _openapi_validate) : ABSENT + _openapi_field_hostusers = haskey(_openapi_object, "hostUsers") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["hostUsers"], _openapi_validate) : ABSENT + _openapi_field_hostname = haskey(_openapi_object, "hostname") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostname"], _openapi_validate) : ABSENT + _openapi_field_hostnameoverride = haskey(_openapi_object, "hostnameOverride") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostnameOverride"], _openapi_validate) : ABSENT + _openapi_field_imagepullsecrets = haskey(_openapi_object, "imagePullSecrets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}}, _openapi_object["imagePullSecrets"], _openapi_validate) : ABSENT + _openapi_field_initcontainers = haskey(_openapi_object, "initContainers") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Container}}}, _openapi_object["initContainers"], _openapi_validate) : ABSENT + _openapi_field_nodename = haskey(_openapi_object, "nodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nodeName"], _openapi_validate) : ABSENT + _openapi_field_nodeselector = haskey(_openapi_object, "nodeSelector") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecNodeSelector,Nothing}, _openapi_object["nodeSelector"], _openapi_validate) : ABSENT + _openapi_field_os = haskey(_openapi_object, "os") ? _decode(Union{Absent,IoK8sApiCoreV1PodOS,Nothing}, _openapi_object["os"], _openapi_validate) : ABSENT + _openapi_field_overhead = haskey(_openapi_object, "overhead") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpecOverhead,Nothing}, _openapi_object["overhead"], _openapi_validate) : ABSENT + _openapi_field_preemptionpolicy = haskey(_openapi_object, "preemptionPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["preemptionPolicy"], _openapi_validate) : ABSENT + _openapi_field_priority = haskey(_openapi_object, "priority") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["priority"], _openapi_validate) : ABSENT + _openapi_field_priorityclassname = haskey(_openapi_object, "priorityClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["priorityClassName"], _openapi_validate) : ABSENT + _openapi_field_readinessgates = haskey(_openapi_object, "readinessGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodReadinessGate}}}, _openapi_object["readinessGates"], _openapi_validate) : ABSENT + _openapi_field_resourceclaims = haskey(_openapi_object, "resourceClaims") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaim}}}, _openapi_object["resourceClaims"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_restartpolicy = haskey(_openapi_object, "restartPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["restartPolicy"], _openapi_validate) : ABSENT + _openapi_field_runtimeclassname = haskey(_openapi_object, "runtimeClassName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["runtimeClassName"], _openapi_validate) : ABSENT + _openapi_field_schedulername = haskey(_openapi_object, "schedulerName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["schedulerName"], _openapi_validate) : ABSENT + _openapi_field_schedulinggates = haskey(_openapi_object, "schedulingGates") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodSchedulingGate}}}, _openapi_object["schedulingGates"], _openapi_validate) : ABSENT + _openapi_field_securitycontext = haskey(_openapi_object, "securityContext") ? _decode(Union{Absent,IoK8sApiCoreV1PodSecurityContext,Nothing}, _openapi_object["securityContext"], _openapi_validate) : ABSENT + _openapi_field_serviceaccount = haskey(_openapi_object, "serviceAccount") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccount"], _openapi_validate) : ABSENT + _openapi_field_serviceaccountname = haskey(_openapi_object, "serviceAccountName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["serviceAccountName"], _openapi_validate) : ABSENT + _openapi_field_sethostnameasfqdn = haskey(_openapi_object, "setHostnameAsFQDN") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["setHostnameAsFQDN"], _openapi_validate) : ABSENT + _openapi_field_shareprocessnamespace = haskey(_openapi_object, "shareProcessNamespace") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["shareProcessNamespace"], _openapi_validate) : ABSENT + _openapi_field_subdomain = haskey(_openapi_object, "subdomain") ? _decode(Union{Absent,Nothing,String}, _openapi_object["subdomain"], _openapi_validate) : ABSENT + _openapi_field_terminationgraceperiodseconds = haskey(_openapi_object, "terminationGracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["terminationGracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_tolerations = haskey(_openapi_object, "tolerations") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Toleration}}}, _openapi_object["tolerations"], _openapi_validate) : ABSENT + _openapi_field_topologyspreadconstraints = haskey(_openapi_object, "topologySpreadConstraints") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1TopologySpreadConstraint}}}, _openapi_object["topologySpreadConstraints"], _openapi_validate) : ABSENT + _openapi_field_volumes = haskey(_openapi_object, "volumes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1Volume}}}, _openapi_object["volumes"], _openapi_validate) : ABSENT + _openapi_field_workloadref = haskey(_openapi_object, "workloadRef") ? _decode(Union{Absent,IoK8sApiCoreV1WorkloadReference,Nothing}, _openapi_object["workloadRef"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("activeDeadlineSeconds","affinity","automountServiceAccountToken","containers","dnsConfig","dnsPolicy","enableServiceLinks","ephemeralContainers","hostAliases","hostIPC","hostNetwork","hostPID","hostUsers","hostname","hostnameOverride","imagePullSecrets","initContainers","nodeName","nodeSelector","os","overhead","preemptionPolicy","priority","priorityClassName","readinessGates","resourceClaims","resources","restartPolicy","runtimeClassName","schedulerName","schedulingGates","securityContext","serviceAccount","serviceAccountName","setHostnameAsFQDN","shareProcessNamespace","subdomain","terminationGracePeriodSeconds","tolerations","topologySpreadConstraints","volumes","workloadRef") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodSpec(; activedeadlineseconds = _openapi_field_activedeadlineseconds, affinity = _openapi_field_affinity, automountserviceaccounttoken = _openapi_field_automountserviceaccounttoken, containers = _openapi_field_containers, dnsconfig = _openapi_field_dnsconfig, dnspolicy = _openapi_field_dnspolicy, enableservicelinks = _openapi_field_enableservicelinks, ephemeralcontainers = _openapi_field_ephemeralcontainers, hostaliases = _openapi_field_hostaliases, hostipc = _openapi_field_hostipc, hostnetwork = _openapi_field_hostnetwork, hostpid = _openapi_field_hostpid, hostusers = _openapi_field_hostusers, hostname = _openapi_field_hostname, hostnameoverride = _openapi_field_hostnameoverride, imagepullsecrets = _openapi_field_imagepullsecrets, initcontainers = _openapi_field_initcontainers, nodename = _openapi_field_nodename, nodeselector = _openapi_field_nodeselector, os = _openapi_field_os, overhead = _openapi_field_overhead, preemptionpolicy = _openapi_field_preemptionpolicy, priority = _openapi_field_priority, priorityclassname = _openapi_field_priorityclassname, readinessgates = _openapi_field_readinessgates, resourceclaims = _openapi_field_resourceclaims, resources = _openapi_field_resources, restartpolicy = _openapi_field_restartpolicy, runtimeclassname = _openapi_field_runtimeclassname, schedulername = _openapi_field_schedulername, schedulinggates = _openapi_field_schedulinggates, securitycontext = _openapi_field_securitycontext, serviceaccount = _openapi_field_serviceaccount, serviceaccountname = _openapi_field_serviceaccountname, sethostnameasfqdn = _openapi_field_sethostnameasfqdn, shareprocessnamespace = _openapi_field_shareprocessnamespace, subdomain = _openapi_field_subdomain, terminationgraceperiodseconds = _openapi_field_terminationgraceperiodseconds, tolerations = _openapi_field_tolerations, topologyspreadconstraints = _openapi_field_topologyspreadconstraints, volumes = _openapi_field_volumes, workloadref = _openapi_field_workloadref, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.activedeadlineseconds isa Absent || (_openapi_output["activeDeadlineSeconds"] = _encode(_openapi_value.activedeadlineseconds)) + _openapi_value.affinity isa Absent || (_openapi_output["affinity"] = _encode(_openapi_value.affinity)) + _openapi_value.automountserviceaccounttoken isa Absent || (_openapi_output["automountServiceAccountToken"] = _encode(_openapi_value.automountserviceaccounttoken)) + _openapi_value.containers isa Absent || (_openapi_output["containers"] = _encode(_openapi_value.containers)) + _openapi_value.dnsconfig isa Absent || (_openapi_output["dnsConfig"] = _encode(_openapi_value.dnsconfig)) + _openapi_value.dnspolicy isa Absent || (_openapi_output["dnsPolicy"] = _encode(_openapi_value.dnspolicy)) + _openapi_value.enableservicelinks isa Absent || (_openapi_output["enableServiceLinks"] = _encode(_openapi_value.enableservicelinks)) + _openapi_value.ephemeralcontainers isa Absent || (_openapi_output["ephemeralContainers"] = _encode(_openapi_value.ephemeralcontainers)) + _openapi_value.hostaliases isa Absent || (_openapi_output["hostAliases"] = _encode(_openapi_value.hostaliases)) + _openapi_value.hostipc isa Absent || (_openapi_output["hostIPC"] = _encode(_openapi_value.hostipc)) + _openapi_value.hostnetwork isa Absent || (_openapi_output["hostNetwork"] = _encode(_openapi_value.hostnetwork)) + _openapi_value.hostpid isa Absent || (_openapi_output["hostPID"] = _encode(_openapi_value.hostpid)) + _openapi_value.hostusers isa Absent || (_openapi_output["hostUsers"] = _encode(_openapi_value.hostusers)) + _openapi_value.hostname isa Absent || (_openapi_output["hostname"] = _encode(_openapi_value.hostname)) + _openapi_value.hostnameoverride isa Absent || (_openapi_output["hostnameOverride"] = _encode(_openapi_value.hostnameoverride)) + _openapi_value.imagepullsecrets isa Absent || (_openapi_output["imagePullSecrets"] = _encode(_openapi_value.imagepullsecrets)) + _openapi_value.initcontainers isa Absent || (_openapi_output["initContainers"] = _encode(_openapi_value.initcontainers)) + _openapi_value.nodename isa Absent || (_openapi_output["nodeName"] = _encode(_openapi_value.nodename)) + _openapi_value.nodeselector isa Absent || (_openapi_output["nodeSelector"] = _encode(_openapi_value.nodeselector)) + _openapi_value.os isa Absent || (_openapi_output["os"] = _encode(_openapi_value.os)) + _openapi_value.overhead isa Absent || (_openapi_output["overhead"] = _encode(_openapi_value.overhead)) + _openapi_value.preemptionpolicy isa Absent || (_openapi_output["preemptionPolicy"] = _encode(_openapi_value.preemptionpolicy)) + _openapi_value.priority isa Absent || (_openapi_output["priority"] = _encode(_openapi_value.priority)) + _openapi_value.priorityclassname isa Absent || (_openapi_output["priorityClassName"] = _encode(_openapi_value.priorityclassname)) + _openapi_value.readinessgates isa Absent || (_openapi_output["readinessGates"] = _encode(_openapi_value.readinessgates)) + _openapi_value.resourceclaims isa Absent || (_openapi_output["resourceClaims"] = _encode(_openapi_value.resourceclaims)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.restartpolicy isa Absent || (_openapi_output["restartPolicy"] = _encode(_openapi_value.restartpolicy)) + _openapi_value.runtimeclassname isa Absent || (_openapi_output["runtimeClassName"] = _encode(_openapi_value.runtimeclassname)) + _openapi_value.schedulername isa Absent || (_openapi_output["schedulerName"] = _encode(_openapi_value.schedulername)) + _openapi_value.schedulinggates isa Absent || (_openapi_output["schedulingGates"] = _encode(_openapi_value.schedulinggates)) + _openapi_value.securitycontext isa Absent || (_openapi_output["securityContext"] = _encode(_openapi_value.securitycontext)) + _openapi_value.serviceaccount isa Absent || (_openapi_output["serviceAccount"] = _encode(_openapi_value.serviceaccount)) + _openapi_value.serviceaccountname isa Absent || (_openapi_output["serviceAccountName"] = _encode(_openapi_value.serviceaccountname)) + _openapi_value.sethostnameasfqdn isa Absent || (_openapi_output["setHostnameAsFQDN"] = _encode(_openapi_value.sethostnameasfqdn)) + _openapi_value.shareprocessnamespace isa Absent || (_openapi_output["shareProcessNamespace"] = _encode(_openapi_value.shareprocessnamespace)) + _openapi_value.subdomain isa Absent || (_openapi_output["subdomain"] = _encode(_openapi_value.subdomain)) + _openapi_value.terminationgraceperiodseconds isa Absent || (_openapi_output["terminationGracePeriodSeconds"] = _encode(_openapi_value.terminationgraceperiodseconds)) + _openapi_value.tolerations isa Absent || (_openapi_output["tolerations"] = _encode(_openapi_value.tolerations)) + _openapi_value.topologyspreadconstraints isa Absent || (_openapi_output["topologySpreadConstraints"] = _encode(_openapi_value.topologyspreadconstraints)) + _openapi_value.volumes isa Absent || (_openapi_output["volumes"] = _encode(_openapi_value.volumes)) + _openapi_value.workloadref isa Absent || (_openapi_output["workloadRef"] = _encode(_openapi_value.workloadref)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.activedeadlineseconds isa Absent || push!(_openapi_output, "activeDeadlineSeconds" => _openapi_value.activedeadlineseconds) + _openapi_value.affinity isa Absent || push!(_openapi_output, "affinity" => _openapi_value.affinity) + _openapi_value.automountserviceaccounttoken isa Absent || push!(_openapi_output, "automountServiceAccountToken" => _openapi_value.automountserviceaccounttoken) + _openapi_value.containers isa Absent || push!(_openapi_output, "containers" => _openapi_value.containers) + _openapi_value.dnsconfig isa Absent || push!(_openapi_output, "dnsConfig" => _openapi_value.dnsconfig) + _openapi_value.dnspolicy isa Absent || push!(_openapi_output, "dnsPolicy" => _openapi_value.dnspolicy) + _openapi_value.enableservicelinks isa Absent || push!(_openapi_output, "enableServiceLinks" => _openapi_value.enableservicelinks) + _openapi_value.ephemeralcontainers isa Absent || push!(_openapi_output, "ephemeralContainers" => _openapi_value.ephemeralcontainers) + _openapi_value.hostaliases isa Absent || push!(_openapi_output, "hostAliases" => _openapi_value.hostaliases) + _openapi_value.hostipc isa Absent || push!(_openapi_output, "hostIPC" => _openapi_value.hostipc) + _openapi_value.hostnetwork isa Absent || push!(_openapi_output, "hostNetwork" => _openapi_value.hostnetwork) + _openapi_value.hostpid isa Absent || push!(_openapi_output, "hostPID" => _openapi_value.hostpid) + _openapi_value.hostusers isa Absent || push!(_openapi_output, "hostUsers" => _openapi_value.hostusers) + _openapi_value.hostname isa Absent || push!(_openapi_output, "hostname" => _openapi_value.hostname) + _openapi_value.hostnameoverride isa Absent || push!(_openapi_output, "hostnameOverride" => _openapi_value.hostnameoverride) + _openapi_value.imagepullsecrets isa Absent || push!(_openapi_output, "imagePullSecrets" => _openapi_value.imagepullsecrets) + _openapi_value.initcontainers isa Absent || push!(_openapi_output, "initContainers" => _openapi_value.initcontainers) + _openapi_value.nodename isa Absent || push!(_openapi_output, "nodeName" => _openapi_value.nodename) + _openapi_value.nodeselector isa Absent || push!(_openapi_output, "nodeSelector" => _openapi_value.nodeselector) + _openapi_value.os isa Absent || push!(_openapi_output, "os" => _openapi_value.os) + _openapi_value.overhead isa Absent || push!(_openapi_output, "overhead" => _openapi_value.overhead) + _openapi_value.preemptionpolicy isa Absent || push!(_openapi_output, "preemptionPolicy" => _openapi_value.preemptionpolicy) + _openapi_value.priority isa Absent || push!(_openapi_output, "priority" => _openapi_value.priority) + _openapi_value.priorityclassname isa Absent || push!(_openapi_output, "priorityClassName" => _openapi_value.priorityclassname) + _openapi_value.readinessgates isa Absent || push!(_openapi_output, "readinessGates" => _openapi_value.readinessgates) + _openapi_value.resourceclaims isa Absent || push!(_openapi_output, "resourceClaims" => _openapi_value.resourceclaims) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.restartpolicy isa Absent || push!(_openapi_output, "restartPolicy" => _openapi_value.restartpolicy) + _openapi_value.runtimeclassname isa Absent || push!(_openapi_output, "runtimeClassName" => _openapi_value.runtimeclassname) + _openapi_value.schedulername isa Absent || push!(_openapi_output, "schedulerName" => _openapi_value.schedulername) + _openapi_value.schedulinggates isa Absent || push!(_openapi_output, "schedulingGates" => _openapi_value.schedulinggates) + _openapi_value.securitycontext isa Absent || push!(_openapi_output, "securityContext" => _openapi_value.securitycontext) + _openapi_value.serviceaccount isa Absent || push!(_openapi_output, "serviceAccount" => _openapi_value.serviceaccount) + _openapi_value.serviceaccountname isa Absent || push!(_openapi_output, "serviceAccountName" => _openapi_value.serviceaccountname) + _openapi_value.sethostnameasfqdn isa Absent || push!(_openapi_output, "setHostnameAsFQDN" => _openapi_value.sethostnameasfqdn) + _openapi_value.shareprocessnamespace isa Absent || push!(_openapi_output, "shareProcessNamespace" => _openapi_value.shareprocessnamespace) + _openapi_value.subdomain isa Absent || push!(_openapi_output, "subdomain" => _openapi_value.subdomain) + _openapi_value.terminationgraceperiodseconds isa Absent || push!(_openapi_output, "terminationGracePeriodSeconds" => _openapi_value.terminationgraceperiodseconds) + _openapi_value.tolerations isa Absent || push!(_openapi_output, "tolerations" => _openapi_value.tolerations) + _openapi_value.topologyspreadconstraints isa Absent || push!(_openapi_output, "topologySpreadConstraints" => _openapi_value.topologyspreadconstraints) + _openapi_value.volumes isa Absent || push!(_openapi_output, "volumes" => _openapi_value.volumes) + _openapi_value.workloadref isa Absent || push!(_openapi_output, "workloadRef" => _openapi_value.workloadref) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodStatusAllocatedResources + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1PodStatusAllocatedResources}, value) = _decode(IoK8sApiCoreV1PodStatusAllocatedResources, value, true) +function _decode(::Type{IoK8sApiCoreV1PodStatusAllocatedResources}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodStatus/properties/allocatedResources"), _openapi_raw, "decoding IoK8sApiCoreV1PodStatusAllocatedResources"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodStatusAllocatedResources") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodStatusAllocatedResources(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodStatusAllocatedResources) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodStatus/properties/allocatedResources"), _openapi_output, "encoding IoK8sApiCoreV1PodStatusAllocatedResources"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodStatusAllocatedResources) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodCondition + lastprobetime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodCondition}, value) = _decode(IoK8sApiCoreV1PodCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1PodCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCondition"), _openapi_raw, "decoding IoK8sApiCoreV1PodCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodCondition") + _openapi_field_lastprobetime = haskey(_openapi_object, "lastProbeTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastProbeTime"], _openapi_validate) : ABSENT + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1PodCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1PodCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastProbeTime","lastTransitionTime","message","observedGeneration","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodCondition(; lastprobetime = _openapi_field_lastprobetime, lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, observedgeneration = _openapi_field_observedgeneration, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lastprobetime isa Absent || (_openapi_output["lastProbeTime"] = _encode(_openapi_value.lastprobetime)) + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodCondition"), _openapi_output, "encoding IoK8sApiCoreV1PodCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lastprobetime isa Absent || push!(_openapi_output, "lastProbeTime" => _openapi_value.lastprobetime) + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodExtendedResourceClaimStatus + requestmappings::Union{Nothing,Vector{IoK8sApiCoreV1ContainerExtendedResourceRequest}} + resourceclaimname::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodExtendedResourceClaimStatus}, value) = _decode(IoK8sApiCoreV1PodExtendedResourceClaimStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PodExtendedResourceClaimStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PodExtendedResourceClaimStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodExtendedResourceClaimStatus") + _openapi_field_requestmappings = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ContainerExtendedResourceRequest}}, _required(_openapi_object, "requestMappings", "IoK8sApiCoreV1PodExtendedResourceClaimStatus"), _openapi_validate) + _openapi_field_resourceclaimname = _decode(String, _required(_openapi_object, "resourceClaimName", "IoK8sApiCoreV1PodExtendedResourceClaimStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("requestMappings","resourceClaimName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodExtendedResourceClaimStatus(; requestmappings = _openapi_field_requestmappings, resourceclaimname = _openapi_field_resourceclaimname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodExtendedResourceClaimStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.requestmappings isa Absent || (_openapi_output["requestMappings"] = _encode(_openapi_value.requestmappings)) + _openapi_value.resourceclaimname isa Absent || (_openapi_output["resourceClaimName"] = _encode(_openapi_value.resourceclaimname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodExtendedResourceClaimStatus"), _openapi_output, "encoding IoK8sApiCoreV1PodExtendedResourceClaimStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodExtendedResourceClaimStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.requestmappings isa Absent || push!(_openapi_output, "requestMappings" => _openapi_value.requestmappings) + _openapi_value.resourceclaimname isa Absent || push!(_openapi_output, "resourceClaimName" => _openapi_value.resourceclaimname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodIP + ip::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodIP}, value) = _decode(IoK8sApiCoreV1PodIP, value, true) +function _decode(::Type{IoK8sApiCoreV1PodIP}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodIP"), _openapi_raw, "decoding IoK8sApiCoreV1PodIP"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodIP") + _openapi_field_ip = _decode(String, _required(_openapi_object, "ip", "IoK8sApiCoreV1PodIP"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("ip",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodIP(; ip = _openapi_field_ip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodIP) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.ip isa Absent || (_openapi_output["ip"] = _encode(_openapi_value.ip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodIP"), _openapi_output, "encoding IoK8sApiCoreV1PodIP"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodIP) + _openapi_output = Pair{String,Any}[] + _openapi_value.ip isa Absent || push!(_openapi_output, "ip" => _openapi_value.ip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodResourceClaimStatus + name::String + resourceclaimname::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodResourceClaimStatus}, value) = _decode(IoK8sApiCoreV1PodResourceClaimStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PodResourceClaimStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PodResourceClaimStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodResourceClaimStatus") + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApiCoreV1PodResourceClaimStatus"), _openapi_validate) + _openapi_field_resourceclaimname = haskey(_openapi_object, "resourceClaimName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceClaimName"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("name","resourceClaimName") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodResourceClaimStatus(; name = _openapi_field_name, resourceclaimname = _openapi_field_resourceclaimname, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodResourceClaimStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.resourceclaimname isa Absent || (_openapi_output["resourceClaimName"] = _encode(_openapi_value.resourceclaimname)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodResourceClaimStatus"), _openapi_output, "encoding IoK8sApiCoreV1PodResourceClaimStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodResourceClaimStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.resourceclaimname isa Absent || push!(_openapi_output, "resourceClaimName" => _openapi_value.resourceclaimname) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodStatus + allocatedresources::Union{Absent,IoK8sApiCoreV1PodStatusAllocatedResources,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodCondition}}} = ABSENT + containerstatuses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}} = ABSENT + ephemeralcontainerstatuses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}} = ABSENT + extendedresourceclaimstatus::Union{Absent,IoK8sApiCoreV1PodExtendedResourceClaimStatus,Nothing} = ABSENT + hostip::Union{Absent,Nothing,String} = ABSENT + hostips::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostIP}}} = ABSENT + initcontainerstatuses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + nominatednodename::Union{Absent,Nothing,String} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + phase::Union{Absent,Nothing,String} = ABSENT + podip::Union{Absent,Nothing,String} = ABSENT + podips::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodIP}}} = ABSENT + qosclass::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + resize::Union{Absent,Nothing,String} = ABSENT + resourceclaimstatuses::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaimStatus}}} = ABSENT + resources::Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing} = ABSENT + starttime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodStatus}, value) = _decode(IoK8sApiCoreV1PodStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1PodStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodStatus"), _openapi_raw, "decoding IoK8sApiCoreV1PodStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodStatus") + _openapi_field_allocatedresources = haskey(_openapi_object, "allocatedResources") ? _decode(Union{Absent,IoK8sApiCoreV1PodStatusAllocatedResources,Nothing}, _openapi_object["allocatedResources"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_containerstatuses = haskey(_openapi_object, "containerStatuses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}}, _openapi_object["containerStatuses"], _openapi_validate) : ABSENT + _openapi_field_ephemeralcontainerstatuses = haskey(_openapi_object, "ephemeralContainerStatuses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}}, _openapi_object["ephemeralContainerStatuses"], _openapi_validate) : ABSENT + _openapi_field_extendedresourceclaimstatus = haskey(_openapi_object, "extendedResourceClaimStatus") ? _decode(Union{Absent,IoK8sApiCoreV1PodExtendedResourceClaimStatus,Nothing}, _openapi_object["extendedResourceClaimStatus"], _openapi_validate) : ABSENT + _openapi_field_hostip = haskey(_openapi_object, "hostIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["hostIP"], _openapi_validate) : ABSENT + _openapi_field_hostips = haskey(_openapi_object, "hostIPs") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1HostIP}}}, _openapi_object["hostIPs"], _openapi_validate) : ABSENT + _openapi_field_initcontainerstatuses = haskey(_openapi_object, "initContainerStatuses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ContainerStatus}}}, _openapi_object["initContainerStatuses"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_nominatednodename = haskey(_openapi_object, "nominatedNodeName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["nominatedNodeName"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_phase = haskey(_openapi_object, "phase") ? _decode(Union{Absent,Nothing,String}, _openapi_object["phase"], _openapi_validate) : ABSENT + _openapi_field_podip = haskey(_openapi_object, "podIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["podIP"], _openapi_validate) : ABSENT + _openapi_field_podips = haskey(_openapi_object, "podIPs") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodIP}}}, _openapi_object["podIPs"], _openapi_validate) : ABSENT + _openapi_field_qosclass = haskey(_openapi_object, "qosClass") ? _decode(Union{Absent,Nothing,String}, _openapi_object["qosClass"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_resize = haskey(_openapi_object, "resize") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resize"], _openapi_validate) : ABSENT + _openapi_field_resourceclaimstatuses = haskey(_openapi_object, "resourceClaimStatuses") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1PodResourceClaimStatus}}}, _openapi_object["resourceClaimStatuses"], _openapi_validate) : ABSENT + _openapi_field_resources = haskey(_openapi_object, "resources") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceRequirements,Nothing}, _openapi_object["resources"], _openapi_validate) : ABSENT + _openapi_field_starttime = haskey(_openapi_object, "startTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["startTime"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allocatedResources","conditions","containerStatuses","ephemeralContainerStatuses","extendedResourceClaimStatus","hostIP","hostIPs","initContainerStatuses","message","nominatedNodeName","observedGeneration","phase","podIP","podIPs","qosClass","reason","resize","resourceClaimStatuses","resources","startTime") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodStatus(; allocatedresources = _openapi_field_allocatedresources, conditions = _openapi_field_conditions, containerstatuses = _openapi_field_containerstatuses, ephemeralcontainerstatuses = _openapi_field_ephemeralcontainerstatuses, extendedresourceclaimstatus = _openapi_field_extendedresourceclaimstatus, hostip = _openapi_field_hostip, hostips = _openapi_field_hostips, initcontainerstatuses = _openapi_field_initcontainerstatuses, message = _openapi_field_message, nominatednodename = _openapi_field_nominatednodename, observedgeneration = _openapi_field_observedgeneration, phase = _openapi_field_phase, podip = _openapi_field_podip, podips = _openapi_field_podips, qosclass = _openapi_field_qosclass, reason = _openapi_field_reason, resize = _openapi_field_resize, resourceclaimstatuses = _openapi_field_resourceclaimstatuses, resources = _openapi_field_resources, starttime = _openapi_field_starttime, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allocatedresources isa Absent || (_openapi_output["allocatedResources"] = _encode(_openapi_value.allocatedresources)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.containerstatuses isa Absent || (_openapi_output["containerStatuses"] = _encode(_openapi_value.containerstatuses)) + _openapi_value.ephemeralcontainerstatuses isa Absent || (_openapi_output["ephemeralContainerStatuses"] = _encode(_openapi_value.ephemeralcontainerstatuses)) + _openapi_value.extendedresourceclaimstatus isa Absent || (_openapi_output["extendedResourceClaimStatus"] = _encode(_openapi_value.extendedresourceclaimstatus)) + _openapi_value.hostip isa Absent || (_openapi_output["hostIP"] = _encode(_openapi_value.hostip)) + _openapi_value.hostips isa Absent || (_openapi_output["hostIPs"] = _encode(_openapi_value.hostips)) + _openapi_value.initcontainerstatuses isa Absent || (_openapi_output["initContainerStatuses"] = _encode(_openapi_value.initcontainerstatuses)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.nominatednodename isa Absent || (_openapi_output["nominatedNodeName"] = _encode(_openapi_value.nominatednodename)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.phase isa Absent || (_openapi_output["phase"] = _encode(_openapi_value.phase)) + _openapi_value.podip isa Absent || (_openapi_output["podIP"] = _encode(_openapi_value.podip)) + _openapi_value.podips isa Absent || (_openapi_output["podIPs"] = _encode(_openapi_value.podips)) + _openapi_value.qosclass isa Absent || (_openapi_output["qosClass"] = _encode(_openapi_value.qosclass)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.resize isa Absent || (_openapi_output["resize"] = _encode(_openapi_value.resize)) + _openapi_value.resourceclaimstatuses isa Absent || (_openapi_output["resourceClaimStatuses"] = _encode(_openapi_value.resourceclaimstatuses)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + _openapi_value.starttime isa Absent || (_openapi_output["startTime"] = _encode(_openapi_value.starttime)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodStatus"), _openapi_output, "encoding IoK8sApiCoreV1PodStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.allocatedresources isa Absent || push!(_openapi_output, "allocatedResources" => _openapi_value.allocatedresources) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.containerstatuses isa Absent || push!(_openapi_output, "containerStatuses" => _openapi_value.containerstatuses) + _openapi_value.ephemeralcontainerstatuses isa Absent || push!(_openapi_output, "ephemeralContainerStatuses" => _openapi_value.ephemeralcontainerstatuses) + _openapi_value.extendedresourceclaimstatus isa Absent || push!(_openapi_output, "extendedResourceClaimStatus" => _openapi_value.extendedresourceclaimstatus) + _openapi_value.hostip isa Absent || push!(_openapi_output, "hostIP" => _openapi_value.hostip) + _openapi_value.hostips isa Absent || push!(_openapi_output, "hostIPs" => _openapi_value.hostips) + _openapi_value.initcontainerstatuses isa Absent || push!(_openapi_output, "initContainerStatuses" => _openapi_value.initcontainerstatuses) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.nominatednodename isa Absent || push!(_openapi_output, "nominatedNodeName" => _openapi_value.nominatednodename) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.phase isa Absent || push!(_openapi_output, "phase" => _openapi_value.phase) + _openapi_value.podip isa Absent || push!(_openapi_output, "podIP" => _openapi_value.podip) + _openapi_value.podips isa Absent || push!(_openapi_output, "podIPs" => _openapi_value.podips) + _openapi_value.qosclass isa Absent || push!(_openapi_output, "qosClass" => _openapi_value.qosclass) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.resize isa Absent || push!(_openapi_output, "resize" => _openapi_value.resize) + _openapi_value.resourceclaimstatuses isa Absent || push!(_openapi_output, "resourceClaimStatuses" => _openapi_value.resourceclaimstatuses) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + _openapi_value.starttime isa Absent || push!(_openapi_output, "startTime" => _openapi_value.starttime) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Pod + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PodSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1PodStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Pod}, value) = _decode(IoK8sApiCoreV1Pod, value, true) +function _decode(::Type{IoK8sApiCoreV1Pod}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Pod"), _openapi_raw, "decoding IoK8sApiCoreV1Pod"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Pod") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1PodStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Pod(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Pod) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Pod"), _openapi_output, "encoding IoK8sApiCoreV1Pod"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Pod) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Pod}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodList}, value) = _decode(IoK8sApiCoreV1PodList, value, true) +function _decode(::Type{IoK8sApiCoreV1PodList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodList"), _openapi_raw, "decoding IoK8sApiCoreV1PodList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Pod}}, _required(_openapi_object, "items", "IoK8sApiCoreV1PodList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodList"), _openapi_output, "encoding IoK8sApiCoreV1PodList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodTemplateSpec + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1PodSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, value) = _decode(IoK8sApiCoreV1PodTemplateSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1PodTemplateSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_raw, "decoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodTemplateSpec") + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1PodSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("metadata","spec") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodTemplateSpec(; metadata = _openapi_field_metadata, spec = _openapi_field_spec, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateSpec"), _openapi_output, "encoding IoK8sApiCoreV1PodTemplateSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodTemplateSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodTemplate + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + template::Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodTemplate}, value) = _decode(IoK8sApiCoreV1PodTemplate, value, true) +function _decode(::Type{IoK8sApiCoreV1PodTemplate}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplate"), _openapi_raw, "decoding IoK8sApiCoreV1PodTemplate"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodTemplate") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_template = haskey(_openapi_object, "template") ? _decode(Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing}, _openapi_object["template"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","template") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodTemplate(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, template = _openapi_field_template, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodTemplate) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplate"), _openapi_output, "encoding IoK8sApiCoreV1PodTemplate"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodTemplate) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1PodTemplateList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1PodTemplate}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1PodTemplateList}, value) = _decode(IoK8sApiCoreV1PodTemplateList, value, true) +function _decode(::Type{IoK8sApiCoreV1PodTemplateList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateList"), _openapi_raw, "decoding IoK8sApiCoreV1PodTemplateList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1PodTemplateList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1PodTemplate}}, _required(_openapi_object, "items", "IoK8sApiCoreV1PodTemplateList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1PodTemplateList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1PodTemplateList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.PodTemplateList"), _openapi_output, "encoding IoK8sApiCoreV1PodTemplateList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1PodTemplateList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationControllerSpecSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationControllerSpecSelector}, value) = _decode(IoK8sApiCoreV1ReplicationControllerSpecSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationControllerSpecSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec/properties/selector"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationControllerSpecSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationControllerSpecSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationControllerSpecSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationControllerSpecSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec/properties/selector"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationControllerSpecSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationControllerSpecSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationControllerSpec + minreadyseconds::Union{Absent,Int32,Nothing} = ABSENT + replicas::Union{Absent,Int32,Nothing} = ABSENT + selector::Union{Absent,IoK8sApiCoreV1ReplicationControllerSpecSelector,Nothing} = ABSENT + template::Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationControllerSpec}, value) = _decode(IoK8sApiCoreV1ReplicationControllerSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationControllerSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationControllerSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationControllerSpec") + _openapi_field_minreadyseconds = haskey(_openapi_object, "minReadySeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["minReadySeconds"], _openapi_validate) : ABSENT + _openapi_field_replicas = haskey(_openapi_object, "replicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["replicas"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApiCoreV1ReplicationControllerSpecSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_template = haskey(_openapi_object, "template") ? _decode(Union{Absent,IoK8sApiCoreV1PodTemplateSpec,Nothing}, _openapi_object["template"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("minReadySeconds","replicas","selector","template") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationControllerSpec(; minreadyseconds = _openapi_field_minreadyseconds, replicas = _openapi_field_replicas, selector = _openapi_field_selector, template = _openapi_field_template, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationControllerSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.minreadyseconds isa Absent || (_openapi_output["minReadySeconds"] = _encode(_openapi_value.minreadyseconds)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.template isa Absent || (_openapi_output["template"] = _encode(_openapi_value.template)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerSpec"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationControllerSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationControllerSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.minreadyseconds isa Absent || push!(_openapi_output, "minReadySeconds" => _openapi_value.minreadyseconds) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.template isa Absent || push!(_openapi_output, "template" => _openapi_value.template) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationControllerCondition + lasttransitiontime::Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationControllerCondition}, value) = _decode(IoK8sApiCoreV1ReplicationControllerCondition, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationControllerCondition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationControllerCondition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationControllerCondition") + _openapi_field_lasttransitiontime = haskey(_openapi_object, "lastTransitionTime") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _openapi_object["lastTransitionTime"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApiCoreV1ReplicationControllerCondition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApiCoreV1ReplicationControllerCondition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationControllerCondition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationControllerCondition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerCondition"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationControllerCondition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationControllerCondition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationControllerStatus + availablereplicas::Union{Absent,Int32,Nothing} = ABSENT + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ReplicationControllerCondition}}} = ABSENT + fullylabeledreplicas::Union{Absent,Int32,Nothing} = ABSENT + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + readyreplicas::Union{Absent,Int32,Nothing} = ABSENT + replicas::Int32 + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationControllerStatus}, value) = _decode(IoK8sApiCoreV1ReplicationControllerStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationControllerStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationControllerStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationControllerStatus") + _openapi_field_availablereplicas = haskey(_openapi_object, "availableReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["availableReplicas"], _openapi_validate) : ABSENT + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ReplicationControllerCondition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_fullylabeledreplicas = haskey(_openapi_object, "fullyLabeledReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["fullyLabeledReplicas"], _openapi_validate) : ABSENT + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_readyreplicas = haskey(_openapi_object, "readyReplicas") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["readyReplicas"], _openapi_validate) : ABSENT + _openapi_field_replicas = _decode(Int32, _required(_openapi_object, "replicas", "IoK8sApiCoreV1ReplicationControllerStatus"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("availableReplicas","conditions","fullyLabeledReplicas","observedGeneration","readyReplicas","replicas") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationControllerStatus(; availablereplicas = _openapi_field_availablereplicas, conditions = _openapi_field_conditions, fullylabeledreplicas = _openapi_field_fullylabeledreplicas, observedgeneration = _openapi_field_observedgeneration, readyreplicas = _openapi_field_readyreplicas, replicas = _openapi_field_replicas, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationControllerStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.availablereplicas isa Absent || (_openapi_output["availableReplicas"] = _encode(_openapi_value.availablereplicas)) + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.fullylabeledreplicas isa Absent || (_openapi_output["fullyLabeledReplicas"] = _encode(_openapi_value.fullylabeledreplicas)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.readyreplicas isa Absent || (_openapi_output["readyReplicas"] = _encode(_openapi_value.readyreplicas)) + _openapi_value.replicas isa Absent || (_openapi_output["replicas"] = _encode(_openapi_value.replicas)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerStatus"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationControllerStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationControllerStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.availablereplicas isa Absent || push!(_openapi_output, "availableReplicas" => _openapi_value.availablereplicas) + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.fullylabeledreplicas isa Absent || push!(_openapi_output, "fullyLabeledReplicas" => _openapi_value.fullylabeledreplicas) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.readyreplicas isa Absent || push!(_openapi_output, "readyReplicas" => _openapi_value.readyreplicas) + _openapi_value.replicas isa Absent || push!(_openapi_output, "replicas" => _openapi_value.replicas) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationController + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1ReplicationControllerSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1ReplicationControllerStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationController}, value) = _decode(IoK8sApiCoreV1ReplicationController, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationController}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationController"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationController"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationController") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1ReplicationControllerSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1ReplicationControllerStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationController(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationController) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationController"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationController"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationController) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ReplicationControllerList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1ReplicationController}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ReplicationControllerList}, value) = _decode(IoK8sApiCoreV1ReplicationControllerList, value, true) +function _decode(::Type{IoK8sApiCoreV1ReplicationControllerList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerList"), _openapi_raw, "decoding IoK8sApiCoreV1ReplicationControllerList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ReplicationControllerList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ReplicationController}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ReplicationControllerList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ReplicationControllerList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ReplicationControllerList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ReplicationControllerList"), _openapi_output, "encoding IoK8sApiCoreV1ReplicationControllerList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ReplicationControllerList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaSpecHard + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaSpecHard}, value) = _decode(IoK8sApiCoreV1ResourceQuotaSpecHard, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaSpecHard}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec/properties/hard"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaSpecHard"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaSpecHard") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaSpecHard(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaSpecHard) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec/properties/hard"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaSpecHard"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaSpecHard) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScopedResourceSelectorRequirement + operator::String + scopename::String + values::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScopedResourceSelectorRequirement}, value) = _decode(IoK8sApiCoreV1ScopedResourceSelectorRequirement, value, true) +function _decode(::Type{IoK8sApiCoreV1ScopedResourceSelectorRequirement}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement"), _openapi_raw, "decoding IoK8sApiCoreV1ScopedResourceSelectorRequirement"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScopedResourceSelectorRequirement") + _openapi_field_operator = _decode(String, _required(_openapi_object, "operator", "IoK8sApiCoreV1ScopedResourceSelectorRequirement"), _openapi_validate) + _openapi_field_scopename = _decode(String, _required(_openapi_object, "scopeName", "IoK8sApiCoreV1ScopedResourceSelectorRequirement"), _openapi_validate) + _openapi_field_values = haskey(_openapi_object, "values") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["values"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("operator","scopeName","values") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScopedResourceSelectorRequirement(; operator = _openapi_field_operator, scopename = _openapi_field_scopename, values = _openapi_field_values, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScopedResourceSelectorRequirement) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.operator isa Absent || (_openapi_output["operator"] = _encode(_openapi_value.operator)) + _openapi_value.scopename isa Absent || (_openapi_output["scopeName"] = _encode(_openapi_value.scopename)) + _openapi_value.values isa Absent || (_openapi_output["values"] = _encode(_openapi_value.values)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopedResourceSelectorRequirement"), _openapi_output, "encoding IoK8sApiCoreV1ScopedResourceSelectorRequirement"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScopedResourceSelectorRequirement) + _openapi_output = Pair{String,Any}[] + _openapi_value.operator isa Absent || push!(_openapi_output, "operator" => _openapi_value.operator) + _openapi_value.scopename isa Absent || push!(_openapi_output, "scopeName" => _openapi_value.scopename) + _openapi_value.values isa Absent || push!(_openapi_output, "values" => _openapi_value.values) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ScopeSelector + matchexpressions::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ScopedResourceSelectorRequirement}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ScopeSelector}, value) = _decode(IoK8sApiCoreV1ScopeSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ScopeSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopeSelector"), _openapi_raw, "decoding IoK8sApiCoreV1ScopeSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ScopeSelector") + _openapi_field_matchexpressions = haskey(_openapi_object, "matchExpressions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ScopedResourceSelectorRequirement}}}, _openapi_object["matchExpressions"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("matchExpressions",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ScopeSelector(; matchexpressions = _openapi_field_matchexpressions, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ScopeSelector) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.matchexpressions isa Absent || (_openapi_output["matchExpressions"] = _encode(_openapi_value.matchexpressions)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ScopeSelector"), _openapi_output, "encoding IoK8sApiCoreV1ScopeSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ScopeSelector) + _openapi_output = Pair{String,Any}[] + _openapi_value.matchexpressions isa Absent || push!(_openapi_output, "matchExpressions" => _openapi_value.matchexpressions) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaSpec + hard::Union{Absent,IoK8sApiCoreV1ResourceQuotaSpecHard,Nothing} = ABSENT + scopeselector::Union{Absent,IoK8sApiCoreV1ScopeSelector,Nothing} = ABSENT + scopes::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaSpec}, value) = _decode(IoK8sApiCoreV1ResourceQuotaSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaSpec") + _openapi_field_hard = haskey(_openapi_object, "hard") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceQuotaSpecHard,Nothing}, _openapi_object["hard"], _openapi_validate) : ABSENT + _openapi_field_scopeselector = haskey(_openapi_object, "scopeSelector") ? _decode(Union{Absent,IoK8sApiCoreV1ScopeSelector,Nothing}, _openapi_object["scopeSelector"], _openapi_validate) : ABSENT + _openapi_field_scopes = haskey(_openapi_object, "scopes") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["scopes"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hard","scopeSelector","scopes") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaSpec(; hard = _openapi_field_hard, scopeselector = _openapi_field_scopeselector, scopes = _openapi_field_scopes, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hard isa Absent || (_openapi_output["hard"] = _encode(_openapi_value.hard)) + _openapi_value.scopeselector isa Absent || (_openapi_output["scopeSelector"] = _encode(_openapi_value.scopeselector)) + _openapi_value.scopes isa Absent || (_openapi_output["scopes"] = _encode(_openapi_value.scopes)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaSpec"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.hard isa Absent || push!(_openapi_output, "hard" => _openapi_value.hard) + _openapi_value.scopeselector isa Absent || push!(_openapi_output, "scopeSelector" => _openapi_value.scopeselector) + _openapi_value.scopes isa Absent || push!(_openapi_output, "scopes" => _openapi_value.scopes) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaStatusHard + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaStatusHard}, value) = _decode(IoK8sApiCoreV1ResourceQuotaStatusHard, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaStatusHard}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus/properties/hard"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaStatusHard"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaStatusHard") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaStatusHard(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatusHard) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus/properties/hard"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaStatusHard"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatusHard) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaStatusUsed + additional_properties::Dict{String,IoK8sApimachineryPkgApiResourceQuantity} = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaStatusUsed}, value) = _decode(IoK8sApiCoreV1ResourceQuotaStatusUsed, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaStatusUsed}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus/properties/used"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaStatusUsed"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaStatusUsed") + _openapi_additional_properties = Dict{String,IoK8sApimachineryPkgApiResourceQuantity}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(IoK8sApimachineryPkgApiResourceQuantity, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaStatusUsed(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatusUsed) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus/properties/used"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaStatusUsed"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatusUsed) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaStatus + hard::Union{Absent,IoK8sApiCoreV1ResourceQuotaStatusHard,Nothing} = ABSENT + used::Union{Absent,IoK8sApiCoreV1ResourceQuotaStatusUsed,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaStatus}, value) = _decode(IoK8sApiCoreV1ResourceQuotaStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaStatus") + _openapi_field_hard = haskey(_openapi_object, "hard") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceQuotaStatusHard,Nothing}, _openapi_object["hard"], _openapi_validate) : ABSENT + _openapi_field_used = haskey(_openapi_object, "used") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceQuotaStatusUsed,Nothing}, _openapi_object["used"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("hard","used") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaStatus(; hard = _openapi_field_hard, used = _openapi_field_used, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.hard isa Absent || (_openapi_output["hard"] = _encode(_openapi_value.hard)) + _openapi_value.used isa Absent || (_openapi_output["used"] = _encode(_openapi_value.used)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaStatus"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.hard isa Absent || push!(_openapi_output, "hard" => _openapi_value.hard) + _openapi_value.used isa Absent || push!(_openapi_output, "used" => _openapi_value.used) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuota + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1ResourceQuotaSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1ResourceQuotaStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuota}, value) = _decode(IoK8sApiCoreV1ResourceQuota, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuota}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuota"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuota"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuota") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceQuotaSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1ResourceQuotaStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuota(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuota) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuota"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuota"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuota) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ResourceQuotaList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1ResourceQuota}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ResourceQuotaList}, value) = _decode(IoK8sApiCoreV1ResourceQuotaList, value, true) +function _decode(::Type{IoK8sApiCoreV1ResourceQuotaList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaList"), _openapi_raw, "decoding IoK8sApiCoreV1ResourceQuotaList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ResourceQuotaList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ResourceQuota}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ResourceQuotaList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ResourceQuotaList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ResourceQuotaList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ResourceQuotaList"), _openapi_output, "encoding IoK8sApiCoreV1ResourceQuotaList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ResourceQuotaList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretData + additional_properties::Dict{String,Vector{UInt8}} = Dict{String,Vector{UInt8}}() +end +_decode(::Type{IoK8sApiCoreV1SecretData}, value) = _decode(IoK8sApiCoreV1SecretData, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretData}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret/properties/data"), _openapi_raw, "decoding IoK8sApiCoreV1SecretData"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretData") + _openapi_additional_properties = Dict{String,Vector{UInt8}}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Vector{UInt8}, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretData(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretData) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret/properties/data"), _openapi_output, "encoding IoK8sApiCoreV1SecretData"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretData) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretStringData + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1SecretStringData}, value) = _decode(IoK8sApiCoreV1SecretStringData, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretStringData}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret/properties/stringData"), _openapi_raw, "decoding IoK8sApiCoreV1SecretStringData"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretStringData") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretStringData(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretStringData) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret/properties/stringData"), _openapi_output, "encoding IoK8sApiCoreV1SecretStringData"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretStringData) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Secret + apiversion::Union{Absent,Nothing,String} = ABSENT + data::Union{Absent,IoK8sApiCoreV1SecretData,Nothing} = ABSENT + immutable::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + stringdata::Union{Absent,IoK8sApiCoreV1SecretStringData,Nothing} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Secret}, value) = _decode(IoK8sApiCoreV1Secret, value, true) +function _decode(::Type{IoK8sApiCoreV1Secret}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret"), _openapi_raw, "decoding IoK8sApiCoreV1Secret"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Secret") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_data = haskey(_openapi_object, "data") ? _decode(Union{Absent,IoK8sApiCoreV1SecretData,Nothing}, _openapi_object["data"], _openapi_validate) : ABSENT + _openapi_field_immutable = haskey(_openapi_object, "immutable") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["immutable"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_stringdata = haskey(_openapi_object, "stringData") ? _decode(Union{Absent,IoK8sApiCoreV1SecretStringData,Nothing}, _openapi_object["stringData"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","data","immutable","kind","metadata","stringData","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Secret(; apiversion = _openapi_field_apiversion, data = _openapi_field_data, immutable = _openapi_field_immutable, kind = _openapi_field_kind, metadata = _openapi_field_metadata, stringdata = _openapi_field_stringdata, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Secret) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.data isa Absent || (_openapi_output["data"] = _encode(_openapi_value.data)) + _openapi_value.immutable isa Absent || (_openapi_output["immutable"] = _encode(_openapi_value.immutable)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.stringdata isa Absent || (_openapi_output["stringData"] = _encode(_openapi_value.stringdata)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Secret"), _openapi_output, "encoding IoK8sApiCoreV1Secret"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Secret) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.data isa Absent || push!(_openapi_output, "data" => _openapi_value.data) + _openapi_value.immutable isa Absent || push!(_openapi_output, "immutable" => _openapi_value.immutable) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.stringdata isa Absent || push!(_openapi_output, "stringData" => _openapi_value.stringdata) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SecretList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Secret}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SecretList}, value) = _decode(IoK8sApiCoreV1SecretList, value, true) +function _decode(::Type{IoK8sApiCoreV1SecretList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretList"), _openapi_raw, "decoding IoK8sApiCoreV1SecretList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SecretList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Secret}}, _required(_openapi_object, "items", "IoK8sApiCoreV1SecretList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SecretList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SecretList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SecretList"), _openapi_output, "encoding IoK8sApiCoreV1SecretList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SecretList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServicePort + appprotocol::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + nodeport::Union{Absent,Int32,Nothing} = ABSENT + port::Int32 + protocol::Union{Absent,Nothing,String} = ABSENT + targetport::Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServicePort}, value) = _decode(IoK8sApiCoreV1ServicePort, value, true) +function _decode(::Type{IoK8sApiCoreV1ServicePort}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServicePort"), _openapi_raw, "decoding IoK8sApiCoreV1ServicePort"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServicePort") + _openapi_field_appprotocol = haskey(_openapi_object, "appProtocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["appProtocol"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_nodeport = haskey(_openapi_object, "nodePort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["nodePort"], _openapi_validate) : ABSENT + _openapi_field_port = _decode(Int32, _required(_openapi_object, "port", "IoK8sApiCoreV1ServicePort"), _openapi_validate) + _openapi_field_protocol = haskey(_openapi_object, "protocol") ? _decode(Union{Absent,Nothing,String}, _openapi_object["protocol"], _openapi_validate) : ABSENT + _openapi_field_targetport = haskey(_openapi_object, "targetPort") ? _decode(Union{Absent,IoK8sApimachineryPkgUtilIntstrIntOrString,Nothing}, _openapi_object["targetPort"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("appProtocol","name","nodePort","port","protocol","targetPort") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServicePort(; appprotocol = _openapi_field_appprotocol, name = _openapi_field_name, nodeport = _openapi_field_nodeport, port = _openapi_field_port, protocol = _openapi_field_protocol, targetport = _openapi_field_targetport, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServicePort) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.appprotocol isa Absent || (_openapi_output["appProtocol"] = _encode(_openapi_value.appprotocol)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.nodeport isa Absent || (_openapi_output["nodePort"] = _encode(_openapi_value.nodeport)) + _openapi_value.port isa Absent || (_openapi_output["port"] = _encode(_openapi_value.port)) + _openapi_value.protocol isa Absent || (_openapi_output["protocol"] = _encode(_openapi_value.protocol)) + _openapi_value.targetport isa Absent || (_openapi_output["targetPort"] = _encode(_openapi_value.targetport)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServicePort"), _openapi_output, "encoding IoK8sApiCoreV1ServicePort"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServicePort) + _openapi_output = Pair{String,Any}[] + _openapi_value.appprotocol isa Absent || push!(_openapi_output, "appProtocol" => _openapi_value.appprotocol) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.nodeport isa Absent || push!(_openapi_output, "nodePort" => _openapi_value.nodeport) + _openapi_value.port isa Absent || push!(_openapi_output, "port" => _openapi_value.port) + _openapi_value.protocol isa Absent || push!(_openapi_output, "protocol" => _openapi_value.protocol) + _openapi_value.targetport isa Absent || push!(_openapi_output, "targetPort" => _openapi_value.targetport) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceSpecSelector + additional_properties::Dict{String,String} = Dict{String,String}() +end +_decode(::Type{IoK8sApiCoreV1ServiceSpecSelector}, value) = _decode(IoK8sApiCoreV1ServiceSpecSelector, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceSpecSelector}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceSpec/properties/selector"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceSpecSelector"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceSpecSelector") + _openapi_additional_properties = Dict{String,String}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(String, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceSpecSelector(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceSpecSelector) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceSpec/properties/selector"), _openapi_output, "encoding IoK8sApiCoreV1ServiceSpecSelector"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceSpecSelector) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1SessionAffinityConfig + clientip::Union{Absent,IoK8sApiCoreV1ClientIPConfig,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1SessionAffinityConfig}, value) = _decode(IoK8sApiCoreV1SessionAffinityConfig, value, true) +function _decode(::Type{IoK8sApiCoreV1SessionAffinityConfig}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig"), _openapi_raw, "decoding IoK8sApiCoreV1SessionAffinityConfig"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1SessionAffinityConfig") + _openapi_field_clientip = haskey(_openapi_object, "clientIP") ? _decode(Union{Absent,IoK8sApiCoreV1ClientIPConfig,Nothing}, _openapi_object["clientIP"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("clientIP",) && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1SessionAffinityConfig(; clientip = _openapi_field_clientip, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1SessionAffinityConfig) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.clientip isa Absent || (_openapi_output["clientIP"] = _encode(_openapi_value.clientip)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.SessionAffinityConfig"), _openapi_output, "encoding IoK8sApiCoreV1SessionAffinityConfig"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1SessionAffinityConfig) + _openapi_output = Pair{String,Any}[] + _openapi_value.clientip isa Absent || push!(_openapi_output, "clientIP" => _openapi_value.clientip) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceSpec + allocateloadbalancernodeports::Union{Absent,Bool,Nothing} = ABSENT + clusterip::Union{Absent,Nothing,String} = ABSENT + clusterips::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + externalips::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + externalname::Union{Absent,Nothing,String} = ABSENT + externaltrafficpolicy::Union{Absent,Nothing,String} = ABSENT + healthchecknodeport::Union{Absent,Int32,Nothing} = ABSENT + internaltrafficpolicy::Union{Absent,Nothing,String} = ABSENT + ipfamilies::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + ipfamilypolicy::Union{Absent,Nothing,String} = ABSENT + loadbalancerclass::Union{Absent,Nothing,String} = ABSENT + loadbalancerip::Union{Absent,Nothing,String} = ABSENT + loadbalancersourceranges::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + ports::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ServicePort}}} = ABSENT + publishnotreadyaddresses::Union{Absent,Bool,Nothing} = ABSENT + selector::Union{Absent,IoK8sApiCoreV1ServiceSpecSelector,Nothing} = ABSENT + sessionaffinity::Union{Absent,Nothing,String} = ABSENT + sessionaffinityconfig::Union{Absent,IoK8sApiCoreV1SessionAffinityConfig,Nothing} = ABSENT + trafficdistribution::Union{Absent,Nothing,String} = ABSENT + type_::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceSpec}, value) = _decode(IoK8sApiCoreV1ServiceSpec, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceSpec}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceSpec"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceSpec"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceSpec") + _openapi_field_allocateloadbalancernodeports = haskey(_openapi_object, "allocateLoadBalancerNodePorts") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["allocateLoadBalancerNodePorts"], _openapi_validate) : ABSENT + _openapi_field_clusterip = haskey(_openapi_object, "clusterIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["clusterIP"], _openapi_validate) : ABSENT + _openapi_field_clusterips = haskey(_openapi_object, "clusterIPs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["clusterIPs"], _openapi_validate) : ABSENT + _openapi_field_externalips = haskey(_openapi_object, "externalIPs") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["externalIPs"], _openapi_validate) : ABSENT + _openapi_field_externalname = haskey(_openapi_object, "externalName") ? _decode(Union{Absent,Nothing,String}, _openapi_object["externalName"], _openapi_validate) : ABSENT + _openapi_field_externaltrafficpolicy = haskey(_openapi_object, "externalTrafficPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["externalTrafficPolicy"], _openapi_validate) : ABSENT + _openapi_field_healthchecknodeport = haskey(_openapi_object, "healthCheckNodePort") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["healthCheckNodePort"], _openapi_validate) : ABSENT + _openapi_field_internaltrafficpolicy = haskey(_openapi_object, "internalTrafficPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["internalTrafficPolicy"], _openapi_validate) : ABSENT + _openapi_field_ipfamilies = haskey(_openapi_object, "ipFamilies") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["ipFamilies"], _openapi_validate) : ABSENT + _openapi_field_ipfamilypolicy = haskey(_openapi_object, "ipFamilyPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["ipFamilyPolicy"], _openapi_validate) : ABSENT + _openapi_field_loadbalancerclass = haskey(_openapi_object, "loadBalancerClass") ? _decode(Union{Absent,Nothing,String}, _openapi_object["loadBalancerClass"], _openapi_validate) : ABSENT + _openapi_field_loadbalancerip = haskey(_openapi_object, "loadBalancerIP") ? _decode(Union{Absent,Nothing,String}, _openapi_object["loadBalancerIP"], _openapi_validate) : ABSENT + _openapi_field_loadbalancersourceranges = haskey(_openapi_object, "loadBalancerSourceRanges") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["loadBalancerSourceRanges"], _openapi_validate) : ABSENT + _openapi_field_ports = haskey(_openapi_object, "ports") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ServicePort}}}, _openapi_object["ports"], _openapi_validate) : ABSENT + _openapi_field_publishnotreadyaddresses = haskey(_openapi_object, "publishNotReadyAddresses") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["publishNotReadyAddresses"], _openapi_validate) : ABSENT + _openapi_field_selector = haskey(_openapi_object, "selector") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceSpecSelector,Nothing}, _openapi_object["selector"], _openapi_validate) : ABSENT + _openapi_field_sessionaffinity = haskey(_openapi_object, "sessionAffinity") ? _decode(Union{Absent,Nothing,String}, _openapi_object["sessionAffinity"], _openapi_validate) : ABSENT + _openapi_field_sessionaffinityconfig = haskey(_openapi_object, "sessionAffinityConfig") ? _decode(Union{Absent,IoK8sApiCoreV1SessionAffinityConfig,Nothing}, _openapi_object["sessionAffinityConfig"], _openapi_validate) : ABSENT + _openapi_field_trafficdistribution = haskey(_openapi_object, "trafficDistribution") ? _decode(Union{Absent,Nothing,String}, _openapi_object["trafficDistribution"], _openapi_validate) : ABSENT + _openapi_field_type_ = haskey(_openapi_object, "type") ? _decode(Union{Absent,Nothing,String}, _openapi_object["type"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("allocateLoadBalancerNodePorts","clusterIP","clusterIPs","externalIPs","externalName","externalTrafficPolicy","healthCheckNodePort","internalTrafficPolicy","ipFamilies","ipFamilyPolicy","loadBalancerClass","loadBalancerIP","loadBalancerSourceRanges","ports","publishNotReadyAddresses","selector","sessionAffinity","sessionAffinityConfig","trafficDistribution","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceSpec(; allocateloadbalancernodeports = _openapi_field_allocateloadbalancernodeports, clusterip = _openapi_field_clusterip, clusterips = _openapi_field_clusterips, externalips = _openapi_field_externalips, externalname = _openapi_field_externalname, externaltrafficpolicy = _openapi_field_externaltrafficpolicy, healthchecknodeport = _openapi_field_healthchecknodeport, internaltrafficpolicy = _openapi_field_internaltrafficpolicy, ipfamilies = _openapi_field_ipfamilies, ipfamilypolicy = _openapi_field_ipfamilypolicy, loadbalancerclass = _openapi_field_loadbalancerclass, loadbalancerip = _openapi_field_loadbalancerip, loadbalancersourceranges = _openapi_field_loadbalancersourceranges, ports = _openapi_field_ports, publishnotreadyaddresses = _openapi_field_publishnotreadyaddresses, selector = _openapi_field_selector, sessionaffinity = _openapi_field_sessionaffinity, sessionaffinityconfig = _openapi_field_sessionaffinityconfig, trafficdistribution = _openapi_field_trafficdistribution, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceSpec) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.allocateloadbalancernodeports isa Absent || (_openapi_output["allocateLoadBalancerNodePorts"] = _encode(_openapi_value.allocateloadbalancernodeports)) + _openapi_value.clusterip isa Absent || (_openapi_output["clusterIP"] = _encode(_openapi_value.clusterip)) + _openapi_value.clusterips isa Absent || (_openapi_output["clusterIPs"] = _encode(_openapi_value.clusterips)) + _openapi_value.externalips isa Absent || (_openapi_output["externalIPs"] = _encode(_openapi_value.externalips)) + _openapi_value.externalname isa Absent || (_openapi_output["externalName"] = _encode(_openapi_value.externalname)) + _openapi_value.externaltrafficpolicy isa Absent || (_openapi_output["externalTrafficPolicy"] = _encode(_openapi_value.externaltrafficpolicy)) + _openapi_value.healthchecknodeport isa Absent || (_openapi_output["healthCheckNodePort"] = _encode(_openapi_value.healthchecknodeport)) + _openapi_value.internaltrafficpolicy isa Absent || (_openapi_output["internalTrafficPolicy"] = _encode(_openapi_value.internaltrafficpolicy)) + _openapi_value.ipfamilies isa Absent || (_openapi_output["ipFamilies"] = _encode(_openapi_value.ipfamilies)) + _openapi_value.ipfamilypolicy isa Absent || (_openapi_output["ipFamilyPolicy"] = _encode(_openapi_value.ipfamilypolicy)) + _openapi_value.loadbalancerclass isa Absent || (_openapi_output["loadBalancerClass"] = _encode(_openapi_value.loadbalancerclass)) + _openapi_value.loadbalancerip isa Absent || (_openapi_output["loadBalancerIP"] = _encode(_openapi_value.loadbalancerip)) + _openapi_value.loadbalancersourceranges isa Absent || (_openapi_output["loadBalancerSourceRanges"] = _encode(_openapi_value.loadbalancersourceranges)) + _openapi_value.ports isa Absent || (_openapi_output["ports"] = _encode(_openapi_value.ports)) + _openapi_value.publishnotreadyaddresses isa Absent || (_openapi_output["publishNotReadyAddresses"] = _encode(_openapi_value.publishnotreadyaddresses)) + _openapi_value.selector isa Absent || (_openapi_output["selector"] = _encode(_openapi_value.selector)) + _openapi_value.sessionaffinity isa Absent || (_openapi_output["sessionAffinity"] = _encode(_openapi_value.sessionaffinity)) + _openapi_value.sessionaffinityconfig isa Absent || (_openapi_output["sessionAffinityConfig"] = _encode(_openapi_value.sessionaffinityconfig)) + _openapi_value.trafficdistribution isa Absent || (_openapi_output["trafficDistribution"] = _encode(_openapi_value.trafficdistribution)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceSpec"), _openapi_output, "encoding IoK8sApiCoreV1ServiceSpec"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceSpec) + _openapi_output = Pair{String,Any}[] + _openapi_value.allocateloadbalancernodeports isa Absent || push!(_openapi_output, "allocateLoadBalancerNodePorts" => _openapi_value.allocateloadbalancernodeports) + _openapi_value.clusterip isa Absent || push!(_openapi_output, "clusterIP" => _openapi_value.clusterip) + _openapi_value.clusterips isa Absent || push!(_openapi_output, "clusterIPs" => _openapi_value.clusterips) + _openapi_value.externalips isa Absent || push!(_openapi_output, "externalIPs" => _openapi_value.externalips) + _openapi_value.externalname isa Absent || push!(_openapi_output, "externalName" => _openapi_value.externalname) + _openapi_value.externaltrafficpolicy isa Absent || push!(_openapi_output, "externalTrafficPolicy" => _openapi_value.externaltrafficpolicy) + _openapi_value.healthchecknodeport isa Absent || push!(_openapi_output, "healthCheckNodePort" => _openapi_value.healthchecknodeport) + _openapi_value.internaltrafficpolicy isa Absent || push!(_openapi_output, "internalTrafficPolicy" => _openapi_value.internaltrafficpolicy) + _openapi_value.ipfamilies isa Absent || push!(_openapi_output, "ipFamilies" => _openapi_value.ipfamilies) + _openapi_value.ipfamilypolicy isa Absent || push!(_openapi_output, "ipFamilyPolicy" => _openapi_value.ipfamilypolicy) + _openapi_value.loadbalancerclass isa Absent || push!(_openapi_output, "loadBalancerClass" => _openapi_value.loadbalancerclass) + _openapi_value.loadbalancerip isa Absent || push!(_openapi_output, "loadBalancerIP" => _openapi_value.loadbalancerip) + _openapi_value.loadbalancersourceranges isa Absent || push!(_openapi_output, "loadBalancerSourceRanges" => _openapi_value.loadbalancersourceranges) + _openapi_value.ports isa Absent || push!(_openapi_output, "ports" => _openapi_value.ports) + _openapi_value.publishnotreadyaddresses isa Absent || push!(_openapi_output, "publishNotReadyAddresses" => _openapi_value.publishnotreadyaddresses) + _openapi_value.selector isa Absent || push!(_openapi_output, "selector" => _openapi_value.selector) + _openapi_value.sessionaffinity isa Absent || push!(_openapi_output, "sessionAffinity" => _openapi_value.sessionaffinity) + _openapi_value.sessionaffinityconfig isa Absent || push!(_openapi_output, "sessionAffinityConfig" => _openapi_value.sessionaffinityconfig) + _openapi_value.trafficdistribution isa Absent || push!(_openapi_output, "trafficDistribution" => _openapi_value.trafficdistribution) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Condition + lasttransitiontime::Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing} + message::String + observedgeneration::Union{Absent,Int64,Nothing} = ABSENT + reason::String + status::String + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Condition, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Condition}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Condition") + _openapi_field_lasttransitiontime = _decode(Union{IoK8sApimachineryPkgApisMetaV1Time,Nothing}, _required(_openapi_object, "lastTransitionTime", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_message = _decode(String, _required(_openapi_object, "message", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_observedgeneration = haskey(_openapi_object, "observedGeneration") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["observedGeneration"], _openapi_validate) : ABSENT + _openapi_field_reason = _decode(String, _required(_openapi_object, "reason", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_status = _decode(String, _required(_openapi_object, "status", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1Condition"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("lastTransitionTime","message","observedGeneration","reason","status","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Condition(; lasttransitiontime = _openapi_field_lasttransitiontime, message = _openapi_field_message, observedgeneration = _openapi_field_observedgeneration, reason = _openapi_field_reason, status = _openapi_field_status, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.lasttransitiontime isa Absent || (_openapi_output["lastTransitionTime"] = _encode(_openapi_value.lasttransitiontime)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.observedgeneration isa Absent || (_openapi_output["observedGeneration"] = _encode(_openapi_value.observedgeneration)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Condition"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Condition"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Condition) + _openapi_output = Pair{String,Any}[] + _openapi_value.lasttransitiontime isa Absent || push!(_openapi_output, "lastTransitionTime" => _openapi_value.lasttransitiontime) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.observedgeneration isa Absent || push!(_openapi_output, "observedGeneration" => _openapi_value.observedgeneration) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceStatus + conditions::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}} = ABSENT + loadbalancer::Union{Absent,IoK8sApiCoreV1LoadBalancerStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceStatus}, value) = _decode(IoK8sApiCoreV1ServiceStatus, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceStatus}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceStatus"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceStatus"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceStatus") + _openapi_field_conditions = haskey(_openapi_object, "conditions") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1Condition}}}, _openapi_object["conditions"], _openapi_validate) : ABSENT + _openapi_field_loadbalancer = haskey(_openapi_object, "loadBalancer") ? _decode(Union{Absent,IoK8sApiCoreV1LoadBalancerStatus,Nothing}, _openapi_object["loadBalancer"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("conditions","loadBalancer") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceStatus(; conditions = _openapi_field_conditions, loadbalancer = _openapi_field_loadbalancer, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceStatus) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.conditions isa Absent || (_openapi_output["conditions"] = _encode(_openapi_value.conditions)) + _openapi_value.loadbalancer isa Absent || (_openapi_output["loadBalancer"] = _encode(_openapi_value.loadbalancer)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceStatus"), _openapi_output, "encoding IoK8sApiCoreV1ServiceStatus"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceStatus) + _openapi_output = Pair{String,Any}[] + _openapi_value.conditions isa Absent || push!(_openapi_output, "conditions" => _openapi_value.conditions) + _openapi_value.loadbalancer isa Absent || push!(_openapi_output, "loadBalancer" => _openapi_value.loadbalancer) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1Service + apiversion::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + spec::Union{Absent,IoK8sApiCoreV1ServiceSpec,Nothing} = ABSENT + status::Union{Absent,IoK8sApiCoreV1ServiceStatus,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1Service}, value) = _decode(IoK8sApiCoreV1Service, value, true) +function _decode(::Type{IoK8sApiCoreV1Service}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Service"), _openapi_raw, "decoding IoK8sApiCoreV1Service"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1Service") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_spec = haskey(_openapi_object, "spec") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceSpec,Nothing}, _openapi_object["spec"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,IoK8sApiCoreV1ServiceStatus,Nothing}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","kind","metadata","spec","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1Service(; apiversion = _openapi_field_apiversion, kind = _openapi_field_kind, metadata = _openapi_field_metadata, spec = _openapi_field_spec, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1Service) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.spec isa Absent || (_openapi_output["spec"] = _encode(_openapi_value.spec)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.Service"), _openapi_output, "encoding IoK8sApiCoreV1Service"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1Service) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.spec isa Absent || push!(_openapi_output, "spec" => _openapi_value.spec) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceAccount + apiversion::Union{Absent,Nothing,String} = ABSENT + automountserviceaccounttoken::Union{Absent,Bool,Nothing} = ABSENT + imagepullsecrets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + secrets::Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ObjectReference}}} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceAccount}, value) = _decode(IoK8sApiCoreV1ServiceAccount, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceAccount}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccount"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceAccount"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceAccount") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_automountserviceaccounttoken = haskey(_openapi_object, "automountServiceAccountToken") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["automountServiceAccountToken"], _openapi_validate) : ABSENT + _openapi_field_imagepullsecrets = haskey(_openapi_object, "imagePullSecrets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1LocalObjectReference}}}, _openapi_object["imagePullSecrets"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_secrets = haskey(_openapi_object, "secrets") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApiCoreV1ObjectReference}}}, _openapi_object["secrets"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","automountServiceAccountToken","imagePullSecrets","kind","metadata","secrets") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceAccount(; apiversion = _openapi_field_apiversion, automountserviceaccounttoken = _openapi_field_automountserviceaccounttoken, imagepullsecrets = _openapi_field_imagepullsecrets, kind = _openapi_field_kind, metadata = _openapi_field_metadata, secrets = _openapi_field_secrets, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceAccount) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.automountserviceaccounttoken isa Absent || (_openapi_output["automountServiceAccountToken"] = _encode(_openapi_value.automountserviceaccounttoken)) + _openapi_value.imagepullsecrets isa Absent || (_openapi_output["imagePullSecrets"] = _encode(_openapi_value.imagepullsecrets)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.secrets isa Absent || (_openapi_output["secrets"] = _encode(_openapi_value.secrets)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccount"), _openapi_output, "encoding IoK8sApiCoreV1ServiceAccount"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceAccount) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.automountserviceaccounttoken isa Absent || push!(_openapi_output, "automountServiceAccountToken" => _openapi_value.automountserviceaccounttoken) + _openapi_value.imagepullsecrets isa Absent || push!(_openapi_output, "imagePullSecrets" => _openapi_value.imagepullsecrets) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.secrets isa Absent || push!(_openapi_output, "secrets" => _openapi_value.secrets) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceAccountList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1ServiceAccount}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceAccountList}, value) = _decode(IoK8sApiCoreV1ServiceAccountList, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceAccountList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountList"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceAccountList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceAccountList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1ServiceAccount}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ServiceAccountList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceAccountList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceAccountList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceAccountList"), _openapi_output, "encoding IoK8sApiCoreV1ServiceAccountList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceAccountList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiCoreV1ServiceList + apiversion::Union{Absent,Nothing,String} = ABSENT + items::Union{Nothing,Vector{IoK8sApiCoreV1Service}} + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiCoreV1ServiceList}, value) = _decode(IoK8sApiCoreV1ServiceList, value, true) +function _decode(::Type{IoK8sApiCoreV1ServiceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceList"), _openapi_raw, "decoding IoK8sApiCoreV1ServiceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiCoreV1ServiceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_items = _decode(Union{Nothing,Vector{IoK8sApiCoreV1Service}}, _required(_openapi_object, "items", "IoK8sApiCoreV1ServiceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","items","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiCoreV1ServiceList(; apiversion = _openapi_field_apiversion, items = _openapi_field_items, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiCoreV1ServiceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.items isa Absent || (_openapi_output["items"] = _encode(_openapi_value.items)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.core.v1.ServiceList"), _openapi_output, "encoding IoK8sApiCoreV1ServiceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiCoreV1ServiceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.items isa Absent || push!(_openapi_output, "items" => _openapi_value.items) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Preconditions + resourceversion::Union{Absent,Nothing,String} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Preconditions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Preconditions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Preconditions") + _openapi_field_resourceversion = haskey(_openapi_object, "resourceVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["resourceVersion"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("resourceVersion","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Preconditions(; resourceversion = _openapi_field_resourceversion, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.resourceversion isa Absent || (_openapi_output["resourceVersion"] = _encode(_openapi_value.resourceversion)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Preconditions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Preconditions) + _openapi_output = Pair{String,Any}[] + _openapi_value.resourceversion isa Absent || push!(_openapi_output, "resourceVersion" => _openapi_value.resourceversion) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1DeleteOptions + apiversion::Union{Absent,Nothing,String} = ABSENT + dryrun::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + graceperiodseconds::Union{Absent,Int64,Nothing} = ABSENT + ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + orphandependents::Union{Absent,Bool,Nothing} = ABSENT + preconditions::Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing} = ABSENT + propagationpolicy::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, value) = _decode(IoK8sApimachineryPkgApisMetaV1DeleteOptions, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1DeleteOptions}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1DeleteOptions") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_dryrun = haskey(_openapi_object, "dryRun") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["dryRun"], _openapi_validate) : ABSENT + _openapi_field_graceperiodseconds = haskey(_openapi_object, "gracePeriodSeconds") ? _decode(Union{Absent,Int64,Nothing}, _openapi_object["gracePeriodSeconds"], _openapi_validate) : ABSENT + _openapi_field_ignorestorereaderrorwithclusterbreakingpotential = haskey(_openapi_object, "ignoreStoreReadErrorWithClusterBreakingPotential") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["ignoreStoreReadErrorWithClusterBreakingPotential"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_orphandependents = haskey(_openapi_object, "orphanDependents") ? _decode(Union{Absent,Bool,Nothing}, _openapi_object["orphanDependents"], _openapi_validate) : ABSENT + _openapi_field_preconditions = haskey(_openapi_object, "preconditions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1Preconditions,Nothing}, _openapi_object["preconditions"], _openapi_validate) : ABSENT + _openapi_field_propagationpolicy = haskey(_openapi_object, "propagationPolicy") ? _decode(Union{Absent,Nothing,String}, _openapi_object["propagationPolicy"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","dryRun","gracePeriodSeconds","ignoreStoreReadErrorWithClusterBreakingPotential","kind","orphanDependents","preconditions","propagationPolicy") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1DeleteOptions(; apiversion = _openapi_field_apiversion, dryrun = _openapi_field_dryrun, graceperiodseconds = _openapi_field_graceperiodseconds, ignorestorereaderrorwithclusterbreakingpotential = _openapi_field_ignorestorereaderrorwithclusterbreakingpotential, kind = _openapi_field_kind, orphandependents = _openapi_field_orphandependents, preconditions = _openapi_field_preconditions, propagationpolicy = _openapi_field_propagationpolicy, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.dryrun isa Absent || (_openapi_output["dryRun"] = _encode(_openapi_value.dryrun)) + _openapi_value.graceperiodseconds isa Absent || (_openapi_output["gracePeriodSeconds"] = _encode(_openapi_value.graceperiodseconds)) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || (_openapi_output["ignoreStoreReadErrorWithClusterBreakingPotential"] = _encode(_openapi_value.ignorestorereaderrorwithclusterbreakingpotential)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.orphandependents isa Absent || (_openapi_output["orphanDependents"] = _encode(_openapi_value.orphandependents)) + _openapi_value.preconditions isa Absent || (_openapi_output["preconditions"] = _encode(_openapi_value.preconditions)) + _openapi_value.propagationpolicy isa Absent || (_openapi_output["propagationPolicy"] = _encode(_openapi_value.propagationpolicy)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1DeleteOptions"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1DeleteOptions) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.dryrun isa Absent || push!(_openapi_output, "dryRun" => _openapi_value.dryrun) + _openapi_value.graceperiodseconds isa Absent || push!(_openapi_output, "gracePeriodSeconds" => _openapi_value.graceperiodseconds) + _openapi_value.ignorestorereaderrorwithclusterbreakingpotential isa Absent || push!(_openapi_output, "ignoreStoreReadErrorWithClusterBreakingPotential" => _openapi_value.ignorestorereaderrorwithclusterbreakingpotential) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.orphandependents isa Absent || push!(_openapi_output, "orphanDependents" => _openapi_value.orphandependents) + _openapi_value.preconditions isa Absent || push!(_openapi_output, "preconditions" => _openapi_value.preconditions) + _openapi_value.propagationpolicy isa Absent || push!(_openapi_output, "propagationPolicy" => _openapi_value.propagationpolicy) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApiPolicyV1Eviction + apiversion::Union{Absent,Nothing,String} = ABSENT + deleteoptions::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApiPolicyV1Eviction}, value) = _decode(IoK8sApiPolicyV1Eviction, value, true) +function _decode(::Type{IoK8sApiPolicyV1Eviction}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.policy.v1.Eviction"), _openapi_raw, "decoding IoK8sApiPolicyV1Eviction"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApiPolicyV1Eviction") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_deleteoptions = haskey(_openapi_object, "deleteOptions") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions,Nothing}, _openapi_object["deleteOptions"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ObjectMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","deleteOptions","kind","metadata") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApiPolicyV1Eviction(; apiversion = _openapi_field_apiversion, deleteoptions = _openapi_field_deleteoptions, kind = _openapi_field_kind, metadata = _openapi_field_metadata, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApiPolicyV1Eviction) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.deleteoptions isa Absent || (_openapi_output["deleteOptions"] = _encode(_openapi_value.deleteoptions)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.api.policy.v1.Eviction"), _openapi_output, "encoding IoK8sApiPolicyV1Eviction"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApiPolicyV1Eviction) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.deleteoptions isa Absent || push!(_openapi_output, "deleteOptions" => _openapi_value.deleteoptions) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResource + categories::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::String + name::String + namespaced::Bool + shortnames::Union{Absent,Union{Nothing,Vector{String}}} = ABSENT + singularname::String + storageversionhash::Union{Absent,Nothing,String} = ABSENT + verbs::Union{Nothing,Vector{String}} + version::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResource, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResource}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResource") + _openapi_field_categories = haskey(_openapi_object, "categories") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["categories"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = _decode(String, _required(_openapi_object, "kind", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_name = _decode(String, _required(_openapi_object, "name", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_namespaced = _decode(Bool, _required(_openapi_object, "namespaced", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_shortnames = haskey(_openapi_object, "shortNames") ? _decode(Union{Absent,Union{Nothing,Vector{String}}}, _openapi_object["shortNames"], _openapi_validate) : ABSENT + _openapi_field_singularname = _decode(String, _required(_openapi_object, "singularName", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_storageversionhash = haskey(_openapi_object, "storageVersionHash") ? _decode(Union{Absent,Nothing,String}, _openapi_object["storageVersionHash"], _openapi_validate) : ABSENT + _openapi_field_verbs = _decode(Union{Nothing,Vector{String}}, _required(_openapi_object, "verbs", "IoK8sApimachineryPkgApisMetaV1APIResource"), _openapi_validate) + _openapi_field_version = haskey(_openapi_object, "version") ? _decode(Union{Absent,Nothing,String}, _openapi_object["version"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("categories","group","kind","name","namespaced","shortNames","singularName","storageVersionHash","verbs","version") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResource(; categories = _openapi_field_categories, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, namespaced = _openapi_field_namespaced, shortnames = _openapi_field_shortnames, singularname = _openapi_field_singularname, storageversionhash = _openapi_field_storageversionhash, verbs = _openapi_field_verbs, version = _openapi_field_version, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.categories isa Absent || (_openapi_output["categories"] = _encode(_openapi_value.categories)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.namespaced isa Absent || (_openapi_output["namespaced"] = _encode(_openapi_value.namespaced)) + _openapi_value.shortnames isa Absent || (_openapi_output["shortNames"] = _encode(_openapi_value.shortnames)) + _openapi_value.singularname isa Absent || (_openapi_output["singularName"] = _encode(_openapi_value.singularname)) + _openapi_value.storageversionhash isa Absent || (_openapi_output["storageVersionHash"] = _encode(_openapi_value.storageversionhash)) + _openapi_value.verbs isa Absent || (_openapi_output["verbs"] = _encode(_openapi_value.verbs)) + _openapi_value.version isa Absent || (_openapi_output["version"] = _encode(_openapi_value.version)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResource"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResource) + _openapi_output = Pair{String,Any}[] + _openapi_value.categories isa Absent || push!(_openapi_output, "categories" => _openapi_value.categories) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.namespaced isa Absent || push!(_openapi_output, "namespaced" => _openapi_value.namespaced) + _openapi_value.shortnames isa Absent || push!(_openapi_output, "shortNames" => _openapi_value.shortnames) + _openapi_value.singularname isa Absent || push!(_openapi_output, "singularName" => _openapi_value.singularname) + _openapi_value.storageversionhash isa Absent || push!(_openapi_output, "storageVersionHash" => _openapi_value.storageversionhash) + _openapi_value.verbs isa Absent || push!(_openapi_output, "verbs" => _openapi_value.verbs) + _openapi_value.version isa Absent || push!(_openapi_output, "version" => _openapi_value.version) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1APIResourceList + apiversion::Union{Absent,Nothing,String} = ABSENT + groupversion::String + kind::Union{Absent,Nothing,String} = ABSENT + resources::Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}} + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, value) = _decode(IoK8sApimachineryPkgApisMetaV1APIResourceList, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1APIResourceList}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1APIResourceList") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_groupversion = _decode(String, _required(_openapi_object, "groupVersion", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_resources = _decode(Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1APIResource}}, _required(_openapi_object, "resources", "IoK8sApimachineryPkgApisMetaV1APIResourceList"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","groupVersion","kind","resources") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1APIResourceList(; apiversion = _openapi_field_apiversion, groupversion = _openapi_field_groupversion, kind = _openapi_field_kind, resources = _openapi_field_resources, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.groupversion isa Absent || (_openapi_output["groupVersion"] = _encode(_openapi_value.groupversion)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.resources isa Absent || (_openapi_output["resources"] = _encode(_openapi_value.resources)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1APIResourceList"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1APIResourceList) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.groupversion isa Absent || push!(_openapi_output, "groupVersion" => _openapi_value.groupversion) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.resources isa Absent || push!(_openapi_output, "resources" => _openapi_value.resources) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1JSONPatchItem + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, value) = _decode(IoK8sApimachineryPkgApisMetaV1JSONPatchItem, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1JSONPatchItem}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1JSONPatchItem") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1JSONPatchItem(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.JSONPatch/items"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1JSONPatchItem"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1JSONPatchItem) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const IoK8sApimachineryPkgApisMetaV1JSONPatch = Vector{IoK8sApimachineryPkgApisMetaV1JSONPatchItem} + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Patch + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Patch, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Patch}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Patch") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Patch(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Patch"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Patch"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Patch) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusCause + field::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusCause, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusCause}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusCause") + _openapi_field_field = haskey(_openapi_object, "field") ? _decode(Union{Absent,Nothing,String}, _openapi_object["field"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("field","message","reason") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusCause(; field = _openapi_field_field, message = _openapi_field_message, reason = _openapi_field_reason, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.field isa Absent || (_openapi_output["field"] = _encode(_openapi_value.field)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusCause"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusCause) + _openapi_output = Pair{String,Any}[] + _openapi_value.field isa Absent || push!(_openapi_output, "field" => _openapi_value.field) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1StatusDetails + causes::Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}} = ABSENT + group::Union{Absent,Nothing,String} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + name::Union{Absent,Nothing,String} = ABSENT + retryafterseconds::Union{Absent,Int32,Nothing} = ABSENT + uid::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, value) = _decode(IoK8sApimachineryPkgApisMetaV1StatusDetails, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1StatusDetails}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1StatusDetails") + _openapi_field_causes = haskey(_openapi_object, "causes") ? _decode(Union{Absent,Union{Nothing,Vector{IoK8sApimachineryPkgApisMetaV1StatusCause}}}, _openapi_object["causes"], _openapi_validate) : ABSENT + _openapi_field_group = haskey(_openapi_object, "group") ? _decode(Union{Absent,Nothing,String}, _openapi_object["group"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_name = haskey(_openapi_object, "name") ? _decode(Union{Absent,Nothing,String}, _openapi_object["name"], _openapi_validate) : ABSENT + _openapi_field_retryafterseconds = haskey(_openapi_object, "retryAfterSeconds") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["retryAfterSeconds"], _openapi_validate) : ABSENT + _openapi_field_uid = haskey(_openapi_object, "uid") ? _decode(Union{Absent,Nothing,String}, _openapi_object["uid"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("causes","group","kind","name","retryAfterSeconds","uid") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1StatusDetails(; causes = _openapi_field_causes, group = _openapi_field_group, kind = _openapi_field_kind, name = _openapi_field_name, retryafterseconds = _openapi_field_retryafterseconds, uid = _openapi_field_uid, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.causes isa Absent || (_openapi_output["causes"] = _encode(_openapi_value.causes)) + _openapi_value.group isa Absent || (_openapi_output["group"] = _encode(_openapi_value.group)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.name isa Absent || (_openapi_output["name"] = _encode(_openapi_value.name)) + _openapi_value.retryafterseconds isa Absent || (_openapi_output["retryAfterSeconds"] = _encode(_openapi_value.retryafterseconds)) + _openapi_value.uid isa Absent || (_openapi_output["uid"] = _encode(_openapi_value.uid)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1StatusDetails"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1StatusDetails) + _openapi_output = Pair{String,Any}[] + _openapi_value.causes isa Absent || push!(_openapi_output, "causes" => _openapi_value.causes) + _openapi_value.group isa Absent || push!(_openapi_output, "group" => _openapi_value.group) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.name isa Absent || push!(_openapi_output, "name" => _openapi_value.name) + _openapi_value.retryafterseconds isa Absent || push!(_openapi_output, "retryAfterSeconds" => _openapi_value.retryafterseconds) + _openapi_value.uid isa Absent || push!(_openapi_output, "uid" => _openapi_value.uid) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1Status + apiversion::Union{Absent,Nothing,String} = ABSENT + code::Union{Absent,Int32,Nothing} = ABSENT + details::Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing} = ABSENT + kind::Union{Absent,Nothing,String} = ABSENT + message::Union{Absent,Nothing,String} = ABSENT + metadata::Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing} = ABSENT + reason::Union{Absent,Nothing,String} = ABSENT + status::Union{Absent,Nothing,String} = ABSENT + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, value) = _decode(IoK8sApimachineryPkgApisMetaV1Status, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1Status}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1Status") + _openapi_field_apiversion = haskey(_openapi_object, "apiVersion") ? _decode(Union{Absent,Nothing,String}, _openapi_object["apiVersion"], _openapi_validate) : ABSENT + _openapi_field_code = haskey(_openapi_object, "code") ? _decode(Union{Absent,Int32,Nothing}, _openapi_object["code"], _openapi_validate) : ABSENT + _openapi_field_details = haskey(_openapi_object, "details") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1StatusDetails,Nothing}, _openapi_object["details"], _openapi_validate) : ABSENT + _openapi_field_kind = haskey(_openapi_object, "kind") ? _decode(Union{Absent,Nothing,String}, _openapi_object["kind"], _openapi_validate) : ABSENT + _openapi_field_message = haskey(_openapi_object, "message") ? _decode(Union{Absent,Nothing,String}, _openapi_object["message"], _openapi_validate) : ABSENT + _openapi_field_metadata = haskey(_openapi_object, "metadata") ? _decode(Union{Absent,IoK8sApimachineryPkgApisMetaV1ListMeta,Nothing}, _openapi_object["metadata"], _openapi_validate) : ABSENT + _openapi_field_reason = haskey(_openapi_object, "reason") ? _decode(Union{Absent,Nothing,String}, _openapi_object["reason"], _openapi_validate) : ABSENT + _openapi_field_status = haskey(_openapi_object, "status") ? _decode(Union{Absent,Nothing,String}, _openapi_object["status"], _openapi_validate) : ABSENT + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("apiVersion","code","details","kind","message","metadata","reason","status") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1Status(; apiversion = _openapi_field_apiversion, code = _openapi_field_code, details = _openapi_field_details, kind = _openapi_field_kind, message = _openapi_field_message, metadata = _openapi_field_metadata, reason = _openapi_field_reason, status = _openapi_field_status, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.apiversion isa Absent || (_openapi_output["apiVersion"] = _encode(_openapi_value.apiversion)) + _openapi_value.code isa Absent || (_openapi_output["code"] = _encode(_openapi_value.code)) + _openapi_value.details isa Absent || (_openapi_output["details"] = _encode(_openapi_value.details)) + _openapi_value.kind isa Absent || (_openapi_output["kind"] = _encode(_openapi_value.kind)) + _openapi_value.message isa Absent || (_openapi_output["message"] = _encode(_openapi_value.message)) + _openapi_value.metadata isa Absent || (_openapi_output["metadata"] = _encode(_openapi_value.metadata)) + _openapi_value.reason isa Absent || (_openapi_output["reason"] = _encode(_openapi_value.reason)) + _openapi_value.status isa Absent || (_openapi_output["status"] = _encode(_openapi_value.status)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Status"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1Status"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1Status) + _openapi_output = Pair{String,Any}[] + _openapi_value.apiversion isa Absent || push!(_openapi_output, "apiVersion" => _openapi_value.apiversion) + _openapi_value.code isa Absent || push!(_openapi_output, "code" => _openapi_value.code) + _openapi_value.details isa Absent || push!(_openapi_output, "details" => _openapi_value.details) + _openapi_value.kind isa Absent || push!(_openapi_output, "kind" => _openapi_value.kind) + _openapi_value.message isa Absent || push!(_openapi_output, "message" => _openapi_value.message) + _openapi_value.metadata isa Absent || push!(_openapi_output, "metadata" => _openapi_value.metadata) + _openapi_value.reason isa Absent || push!(_openapi_output, "reason" => _openapi_value.reason) + _openapi_value.status isa Absent || push!(_openapi_output, "status" => _openapi_value.status) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgRuntimeRawExtension + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, value) = _decode(IoK8sApimachineryPkgRuntimeRawExtension, value, true) +function _decode(::Type{IoK8sApimachineryPkgRuntimeRawExtension}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_raw, "decoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgRuntimeRawExtension") + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in () && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgRuntimeRawExtension(; additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = JSON.Object{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.runtime.RawExtension"), _openapi_output, "encoding IoK8sApimachineryPkgRuntimeRawExtension"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgRuntimeRawExtension) + _openapi_output = Pair{String,Any}[] + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +Base.@kwdef struct IoK8sApimachineryPkgApisMetaV1WatchEvent + object::IoK8sApimachineryPkgRuntimeRawExtension + type_::String + additional_properties::Dict{String,Any} = Dict{String,Any}() +end +_decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, value) = _decode(IoK8sApimachineryPkgApisMetaV1WatchEvent, value, true) +function _decode(::Type{IoK8sApimachineryPkgApisMetaV1WatchEvent}, _openapi_raw, _openapi_validate::Bool) + _openapi_validate && _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_raw, "decoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) + _openapi_object = _object(_openapi_raw, "IoK8sApimachineryPkgApisMetaV1WatchEvent") + _openapi_field_object = _decode(IoK8sApimachineryPkgRuntimeRawExtension, _required(_openapi_object, "object", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_field_type_ = _decode(String, _required(_openapi_object, "type", "IoK8sApimachineryPkgApisMetaV1WatchEvent"), _openapi_validate) + _openapi_additional_properties = Dict{String,Any}() + for (_openapi_key, _openapi_item) in _openapi_object + String(_openapi_key) in ("object","type") && continue + _openapi_additional_properties[String(_openapi_key)] = _decode(Any, _openapi_item, _openapi_validate) + end + return IoK8sApimachineryPkgApisMetaV1WatchEvent(; object = _openapi_field_object, type_ = _openapi_field_type_, additional_properties = _openapi_additional_properties) +end +function _encode(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = JSON.Object{String,Any}() + _openapi_value.object isa Absent || (_openapi_output["object"] = _encode(_openapi_value.object)) + _openapi_value.type_ isa Absent || (_openapi_output["type"] = _encode(_openapi_value.type_)) + for (_openapi_key, _openapi_item) in _openapi_value.additional_properties + haskey(_openapi_output, _openapi_key) && throw(ArgumentError("additional property conflicts with declared field: " * _openapi_key)) + _openapi_output[_openapi_key] = _encode(_openapi_item) + end + return _validate_schema(_SPEC, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"), _openapi_output, "encoding IoK8sApimachineryPkgApisMetaV1WatchEvent"; direction = :neutral) +end + +function _form_fields(_openapi_value::IoK8sApimachineryPkgApisMetaV1WatchEvent) + _openapi_output = Pair{String,Any}[] + _openapi_value.object isa Absent || push!(_openapi_output, "object" => _openapi_value.object) + _openapi_value.type_ isa Absent || push!(_openapi_output, "type" => _openapi_value.type_) + append!(_openapi_output, collect(_openapi_value.additional_properties)) + return _openapi_output +end + +const _OP_getcorev1apiresources = ( + id = "getCoreV1APIResources", + method = "GET", + path = "/api/v1/", + parameters = (), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1APIResourceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " getcorev1apiresources(...)\n\nget available resources\n\n`GET /api/v1/`" +function getcorev1apiresources(; client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + return _request(client, _OP_getcorev1apiresources, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1componentstatus = ( + id = "listCoreV1ComponentStatus", + method = "GET", + path = "/api/v1/componentstatuses", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ComponentStatusList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1componentstatus(...)\n\nlist objects of kind ComponentStatus\n\n`GET /api/v1/componentstatuses`" +function listcorev1componentstatus(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1componentstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1componentstatus = ( + id = "readCoreV1ComponentStatus", + method = "GET", + path = "/api/v1/componentstatuses/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ComponentStatus, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ComponentStatus, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ComponentStatus, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ComponentStatus, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1componentstatuses~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1componentstatus(...)\n\nread the specified ComponentStatus\n\n`GET /api/v1/componentstatuses/{name}`" +function readcorev1componentstatus(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1componentstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1configmapforallnamespaces = ( + id = "listCoreV1ConfigMapForAllNamespaces", + method = "GET", + path = "/api/v1/configmaps", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1configmaps/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1configmapforallnamespaces(...)\n\nlist or watch objects of kind ConfigMap\n\n`GET /api/v1/configmaps`" +function listcorev1configmapforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1configmapforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1endpointsforallnamespaces = ( + id = "listCoreV1EndpointsForAllNamespaces", + method = "GET", + path = "/api/v1/endpoints", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1endpoints/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1endpointsforallnamespaces(...)\n\nlist or watch objects of kind Endpoints\n\n`GET /api/v1/endpoints`" +function listcorev1endpointsforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1endpointsforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1eventforallnamespaces = ( + id = "listCoreV1EventForAllNamespaces", + method = "GET", + path = "/api/v1/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1eventforallnamespaces(...)\n\nlist or watch objects of kind Event\n\n`GET /api/v1/events`" +function listcorev1eventforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1eventforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1limitrangeforallnamespaces = ( + id = "listCoreV1LimitRangeForAllNamespaces", + method = "GET", + path = "/api/v1/limitranges", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1limitranges/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1limitrangeforallnamespaces(...)\n\nlist or watch objects of kind LimitRange\n\n`GET /api/v1/limitranges`" +function listcorev1limitrangeforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1limitrangeforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespace = ( + id = "listCoreV1Namespace", + method = "GET", + path = "/api/v1/namespaces", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1NamespaceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespace(...)\n\nlist or watch objects of kind Namespace\n\n`GET /api/v1/namespaces`" +function listcorev1namespace(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespace, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespace = ( + id = "createCoreV1Namespace", + method = "POST", + path = "/api/v1/namespaces", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespace(...)\n\ncreate a Namespace\n\n`POST /api/v1/namespaces`" +function createcorev1namespace(body::IoK8sApiCoreV1Namespace; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespace, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedbinding = ( + id = "createCoreV1NamespacedBinding", + method = "POST", + path = "/api/v1/namespaces/{namespace}/bindings", + parameters = ((arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/2/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/3/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/parameters/4/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1bindings/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedbinding(...)\n\ncreate a Binding\n\n`POST /api/v1/namespaces/{namespace}/bindings`" +function createcorev1namespacedbinding(namespace::String, body::IoK8sApiCoreV1Binding; dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_createcorev1namespacedbinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedconfigmap = ( + id = "deleteCoreV1CollectionNamespacedConfigMap", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/configmaps", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedconfigmap(...)\n\ndelete collection of ConfigMap\n\n`DELETE /api/v1/namespaces/{namespace}/configmaps`" +function deletecorev1collectionnamespacedconfigmap(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedconfigmap, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedconfigmap = ( + id = "listCoreV1NamespacedConfigMap", + method = "GET", + path = "/api/v1/namespaces/{namespace}/configmaps", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMapList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedconfigmap(...)\n\nlist or watch objects of kind ConfigMap\n\n`GET /api/v1/namespaces/{namespace}/configmaps`" +function listcorev1namespacedconfigmap(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedconfigmap, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedconfigmap = ( + id = "createCoreV1NamespacedConfigMap", + method = "POST", + path = "/api/v1/namespaces/{namespace}/configmaps", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedconfigmap(...)\n\ncreate a ConfigMap\n\n`POST /api/v1/namespaces/{namespace}/configmaps`" +function createcorev1namespacedconfigmap(namespace::String, body::IoK8sApiCoreV1ConfigMap; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedconfigmap, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedconfigmap = ( + id = "deleteCoreV1NamespacedConfigMap", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/configmaps/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedconfigmap(...)\n\ndelete a ConfigMap\n\n`DELETE /api/v1/namespaces/{namespace}/configmaps/{name}`" +function deletecorev1namespacedconfigmap(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedconfigmap, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedconfigmap = ( + id = "readCoreV1NamespacedConfigMap", + method = "GET", + path = "/api/v1/namespaces/{namespace}/configmaps/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedconfigmap(...)\n\nread the specified ConfigMap\n\n`GET /api/v1/namespaces/{namespace}/configmaps/{name}`" +function readcorev1namespacedconfigmap(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedconfigmap, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedconfigmap = ( + id = "patchCoreV1NamespacedConfigMap", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/configmaps/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedconfigmap(...)\n\npartially update the specified ConfigMap\n\n`PATCH /api/v1/namespaces/{namespace}/configmaps/{name}`" +function patchcorev1namespacedconfigmap(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedconfigmap, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedconfigmap = ( + id = "replaceCoreV1NamespacedConfigMap", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/configmaps/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ConfigMap, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1configmaps~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedconfigmap(...)\n\nreplace the specified ConfigMap\n\n`PUT /api/v1/namespaces/{namespace}/configmaps/{name}`" +function replacecorev1namespacedconfigmap(namespace::String, name::String, body::IoK8sApiCoreV1ConfigMap; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedconfigmap, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedendpoints = ( + id = "deleteCoreV1CollectionNamespacedEndpoints", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/endpoints", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedendpoints(...)\n\ndelete collection of Endpoints\n\n`DELETE /api/v1/namespaces/{namespace}/endpoints`" +function deletecorev1collectionnamespacedendpoints(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedendpoints, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedendpoints = ( + id = "listCoreV1NamespacedEndpoints", + method = "GET", + path = "/api/v1/namespaces/{namespace}/endpoints", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1EndpointsList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedendpoints(...)\n\nlist or watch objects of kind Endpoints\n\n`GET /api/v1/namespaces/{namespace}/endpoints`" +function listcorev1namespacedendpoints(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedendpoints, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedendpoints = ( + id = "createCoreV1NamespacedEndpoints", + method = "POST", + path = "/api/v1/namespaces/{namespace}/endpoints", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedendpoints(...)\n\ncreate Endpoints\n\n`POST /api/v1/namespaces/{namespace}/endpoints`" +function createcorev1namespacedendpoints(namespace::String, body::IoK8sApiCoreV1Endpoints; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedendpoints, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedendpoints = ( + id = "deleteCoreV1NamespacedEndpoints", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/endpoints/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedendpoints(...)\n\ndelete Endpoints\n\n`DELETE /api/v1/namespaces/{namespace}/endpoints/{name}`" +function deletecorev1namespacedendpoints(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedendpoints, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedendpoints = ( + id = "readCoreV1NamespacedEndpoints", + method = "GET", + path = "/api/v1/namespaces/{namespace}/endpoints/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedendpoints(...)\n\nread the specified Endpoints\n\n`GET /api/v1/namespaces/{namespace}/endpoints/{name}`" +function readcorev1namespacedendpoints(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedendpoints, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedendpoints = ( + id = "patchCoreV1NamespacedEndpoints", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/endpoints/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedendpoints(...)\n\npartially update the specified Endpoints\n\n`PATCH /api/v1/namespaces/{namespace}/endpoints/{name}`" +function patchcorev1namespacedendpoints(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedendpoints, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedendpoints = ( + id = "replaceCoreV1NamespacedEndpoints", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/endpoints/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Endpoints, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1endpoints~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedendpoints(...)\n\nreplace the specified Endpoints\n\n`PUT /api/v1/namespaces/{namespace}/endpoints/{name}`" +function replacecorev1namespacedendpoints(namespace::String, name::String, body::IoK8sApiCoreV1Endpoints; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedendpoints, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedevent = ( + id = "deleteCoreV1CollectionNamespacedEvent", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedevent(...)\n\ndelete collection of Event\n\n`DELETE /api/v1/namespaces/{namespace}/events`" +function deletecorev1collectionnamespacedevent(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedevent = ( + id = "listCoreV1NamespacedEvent", + method = "GET", + path = "/api/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1EventList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedevent(...)\n\nlist or watch objects of kind Event\n\n`GET /api/v1/namespaces/{namespace}/events`" +function listcorev1namespacedevent(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedevent = ( + id = "createCoreV1NamespacedEvent", + method = "POST", + path = "/api/v1/namespaces/{namespace}/events", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedevent(...)\n\ncreate an Event\n\n`POST /api/v1/namespaces/{namespace}/events`" +function createcorev1namespacedevent(namespace::String, body::IoK8sApiCoreV1Event; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedevent = ( + id = "deleteCoreV1NamespacedEvent", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedevent(...)\n\ndelete an Event\n\n`DELETE /api/v1/namespaces/{namespace}/events/{name}`" +function deletecorev1namespacedevent(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedevent = ( + id = "readCoreV1NamespacedEvent", + method = "GET", + path = "/api/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedevent(...)\n\nread the specified Event\n\n`GET /api/v1/namespaces/{namespace}/events/{name}`" +function readcorev1namespacedevent(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedevent = ( + id = "patchCoreV1NamespacedEvent", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedevent(...)\n\npartially update the specified Event\n\n`PATCH /api/v1/namespaces/{namespace}/events/{name}`" +function patchcorev1namespacedevent(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedevent = ( + id = "replaceCoreV1NamespacedEvent", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/events/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Event, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1events~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedevent(...)\n\nreplace the specified Event\n\n`PUT /api/v1/namespaces/{namespace}/events/{name}`" +function replacecorev1namespacedevent(namespace::String, name::String, body::IoK8sApiCoreV1Event; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedevent, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedlimitrange = ( + id = "deleteCoreV1CollectionNamespacedLimitRange", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/limitranges", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedlimitrange(...)\n\ndelete collection of LimitRange\n\n`DELETE /api/v1/namespaces/{namespace}/limitranges`" +function deletecorev1collectionnamespacedlimitrange(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedlimitrange, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedlimitrange = ( + id = "listCoreV1NamespacedLimitRange", + method = "GET", + path = "/api/v1/namespaces/{namespace}/limitranges", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRangeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedlimitrange(...)\n\nlist or watch objects of kind LimitRange\n\n`GET /api/v1/namespaces/{namespace}/limitranges`" +function listcorev1namespacedlimitrange(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedlimitrange, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedlimitrange = ( + id = "createCoreV1NamespacedLimitRange", + method = "POST", + path = "/api/v1/namespaces/{namespace}/limitranges", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedlimitrange(...)\n\ncreate a LimitRange\n\n`POST /api/v1/namespaces/{namespace}/limitranges`" +function createcorev1namespacedlimitrange(namespace::String, body::IoK8sApiCoreV1LimitRange; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedlimitrange, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedlimitrange = ( + id = "deleteCoreV1NamespacedLimitRange", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/limitranges/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedlimitrange(...)\n\ndelete a LimitRange\n\n`DELETE /api/v1/namespaces/{namespace}/limitranges/{name}`" +function deletecorev1namespacedlimitrange(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedlimitrange, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedlimitrange = ( + id = "readCoreV1NamespacedLimitRange", + method = "GET", + path = "/api/v1/namespaces/{namespace}/limitranges/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedlimitrange(...)\n\nread the specified LimitRange\n\n`GET /api/v1/namespaces/{namespace}/limitranges/{name}`" +function readcorev1namespacedlimitrange(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedlimitrange, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedlimitrange = ( + id = "patchCoreV1NamespacedLimitRange", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/limitranges/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedlimitrange(...)\n\npartially update the specified LimitRange\n\n`PATCH /api/v1/namespaces/{namespace}/limitranges/{name}`" +function patchcorev1namespacedlimitrange(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedlimitrange, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedlimitrange = ( + id = "replaceCoreV1NamespacedLimitRange", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/limitranges/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1LimitRange, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1limitranges~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedlimitrange(...)\n\nreplace the specified LimitRange\n\n`PUT /api/v1/namespaces/{namespace}/limitranges/{name}`" +function replacecorev1namespacedlimitrange(namespace::String, name::String, body::IoK8sApiCoreV1LimitRange; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedlimitrange, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedpersistentvolumeclaim = ( + id = "deleteCoreV1CollectionNamespacedPersistentVolumeClaim", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedpersistentvolumeclaim(...)\n\ndelete collection of PersistentVolumeClaim\n\n`DELETE /api/v1/namespaces/{namespace}/persistentvolumeclaims`" +function deletecorev1collectionnamespacedpersistentvolumeclaim(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedpersistentvolumeclaim, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedpersistentvolumeclaim = ( + id = "listCoreV1NamespacedPersistentVolumeClaim", + method = "GET", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedpersistentvolumeclaim(...)\n\nlist or watch objects of kind PersistentVolumeClaim\n\n`GET /api/v1/namespaces/{namespace}/persistentvolumeclaims`" +function listcorev1namespacedpersistentvolumeclaim(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedpersistentvolumeclaim, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedpersistentvolumeclaim = ( + id = "createCoreV1NamespacedPersistentVolumeClaim", + method = "POST", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedpersistentvolumeclaim(...)\n\ncreate a PersistentVolumeClaim\n\n`POST /api/v1/namespaces/{namespace}/persistentvolumeclaims`" +function createcorev1namespacedpersistentvolumeclaim(namespace::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedpersistentvolumeclaim, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedpersistentvolumeclaim = ( + id = "deleteCoreV1NamespacedPersistentVolumeClaim", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedpersistentvolumeclaim(...)\n\ndelete a PersistentVolumeClaim\n\n`DELETE /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}`" +function deletecorev1namespacedpersistentvolumeclaim(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedpersistentvolumeclaim, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpersistentvolumeclaim = ( + id = "readCoreV1NamespacedPersistentVolumeClaim", + method = "GET", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpersistentvolumeclaim(...)\n\nread the specified PersistentVolumeClaim\n\n`GET /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}`" +function readcorev1namespacedpersistentvolumeclaim(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedpersistentvolumeclaim, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpersistentvolumeclaim = ( + id = "patchCoreV1NamespacedPersistentVolumeClaim", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpersistentvolumeclaim(...)\n\npartially update the specified PersistentVolumeClaim\n\n`PATCH /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}`" +function patchcorev1namespacedpersistentvolumeclaim(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpersistentvolumeclaim, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpersistentvolumeclaim = ( + id = "replaceCoreV1NamespacedPersistentVolumeClaim", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpersistentvolumeclaim(...)\n\nreplace the specified PersistentVolumeClaim\n\n`PUT /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}`" +function replacecorev1namespacedpersistentvolumeclaim(namespace::String, name::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpersistentvolumeclaim, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpersistentvolumeclaimstatus = ( + id = "readCoreV1NamespacedPersistentVolumeClaimStatus", + method = "GET", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpersistentvolumeclaimstatus(...)\n\nread status of the specified PersistentVolumeClaim\n\n`GET /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status`" +function readcorev1namespacedpersistentvolumeclaimstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedpersistentvolumeclaimstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpersistentvolumeclaimstatus = ( + id = "patchCoreV1NamespacedPersistentVolumeClaimStatus", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpersistentvolumeclaimstatus(...)\n\npartially update status of the specified PersistentVolumeClaim\n\n`PATCH /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status`" +function patchcorev1namespacedpersistentvolumeclaimstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpersistentvolumeclaimstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpersistentvolumeclaimstatus = ( + id = "replaceCoreV1NamespacedPersistentVolumeClaimStatus", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaim, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpersistentvolumeclaimstatus(...)\n\nreplace status of the specified PersistentVolumeClaim\n\n`PUT /api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status`" +function replacecorev1namespacedpersistentvolumeclaimstatus(namespace::String, name::String, body::IoK8sApiCoreV1PersistentVolumeClaim; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpersistentvolumeclaimstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedpod = ( + id = "deleteCoreV1CollectionNamespacedPod", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/pods", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedpod(...)\n\ndelete collection of Pod\n\n`DELETE /api/v1/namespaces/{namespace}/pods`" +function deletecorev1collectionnamespacedpod(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedpod, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedpod = ( + id = "listCoreV1NamespacedPod", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedpod(...)\n\nlist or watch objects of kind Pod\n\n`GET /api/v1/namespaces/{namespace}/pods`" +function listcorev1namespacedpod(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedpod, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedpod = ( + id = "createCoreV1NamespacedPod", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedpod(...)\n\ncreate a Pod\n\n`POST /api/v1/namespaces/{namespace}/pods`" +function createcorev1namespacedpod(namespace::String, body::IoK8sApiCoreV1Pod; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedpod, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedpod = ( + id = "deleteCoreV1NamespacedPod", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedpod(...)\n\ndelete a Pod\n\n`DELETE /api/v1/namespaces/{namespace}/pods/{name}`" +function deletecorev1namespacedpod(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedpod, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpod = ( + id = "readCoreV1NamespacedPod", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpod(...)\n\nread the specified Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}`" +function readcorev1namespacedpod(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedpod, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpod = ( + id = "patchCoreV1NamespacedPod", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpod(...)\n\npartially update the specified Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}`" +function patchcorev1namespacedpod(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpod, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpod = ( + id = "replaceCoreV1NamespacedPod", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpod(...)\n\nreplace the specified Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}`" +function replacecorev1namespacedpod(namespace::String, name::String, body::IoK8sApiCoreV1Pod; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpod, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedpodattach = ( + id = "connectCoreV1GetNamespacedPodAttach", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/attach", + parameters = ((arg = :container, name = "container", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/0/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/1/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/2/schema"), content = (), required = true),(arg = :stderr, name = "stderr", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/3/schema"), content = (), required = false),(arg = :stdin, name = "stdin", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/4/schema"), content = (), required = false),(arg = :stdout, name = "stdout", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/5/schema"), content = (), required = false),(arg = :tty, name = "tty", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/6/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedpodattach(...)\n\nconnect GET requests to attach of Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/attach`" +function connectcorev1getnamespacedpodattach(namespace::String, name::String; container::Union{Absent,String} = ABSENT, stderr::Union{Absent,Bool} = ABSENT, stdin::Union{Absent,Bool} = ABSENT, stdout::Union{Absent,Bool} = ABSENT, tty::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:container] = container + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:stderr] = stderr + _openapi_values[:stdin] = stdin + _openapi_values[:stdout] = stdout + _openapi_values[:tty] = tty + return _request(client, _OP_connectcorev1getnamespacedpodattach, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedpodattach = ( + id = "connectCoreV1PostNamespacedPodAttach", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/attach", + parameters = ((arg = :container, name = "container", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/0/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/1/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/2/schema"), content = (), required = true),(arg = :stderr, name = "stderr", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/3/schema"), content = (), required = false),(arg = :stdin, name = "stdin", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/4/schema"), content = (), required = false),(arg = :stdout, name = "stdout", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/5/schema"), content = (), required = false),(arg = :tty, name = "tty", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/parameters/6/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1attach/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedpodattach(...)\n\nconnect POST requests to attach of Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/attach`" +function connectcorev1postnamespacedpodattach(namespace::String, name::String; container::Union{Absent,String} = ABSENT, stderr::Union{Absent,Bool} = ABSENT, stdin::Union{Absent,Bool} = ABSENT, stdout::Union{Absent,Bool} = ABSENT, tty::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:container] = container + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:stderr] = stderr + _openapi_values[:stdin] = stdin + _openapi_values[:stdout] = stdout + _openapi_values[:tty] = tty + return _request(client, _OP_connectcorev1postnamespacedpodattach, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedpodbinding = ( + id = "createCoreV1NamespacedPodBinding", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/binding", + parameters = ((arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/2/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/3/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/4/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/parameters/5/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Binding, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1binding/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedpodbinding(...)\n\ncreate binding of a Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/binding`" +function createcorev1namespacedpodbinding(namespace::String, name::String, body::IoK8sApiCoreV1Binding; dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_createcorev1namespacedpodbinding, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpodephemeralcontainers = ( + id = "readCoreV1NamespacedPodEphemeralcontainers", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpodephemeralcontainers(...)\n\nread ephemeralcontainers of the specified Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers`" +function readcorev1namespacedpodephemeralcontainers(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedpodephemeralcontainers, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpodephemeralcontainers = ( + id = "patchCoreV1NamespacedPodEphemeralcontainers", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpodephemeralcontainers(...)\n\npartially update ephemeralcontainers of the specified Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers`" +function patchcorev1namespacedpodephemeralcontainers(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpodephemeralcontainers, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpodephemeralcontainers = ( + id = "replaceCoreV1NamespacedPodEphemeralcontainers", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1ephemeralcontainers/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpodephemeralcontainers(...)\n\nreplace ephemeralcontainers of the specified Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers`" +function replacecorev1namespacedpodephemeralcontainers(namespace::String, name::String, body::IoK8sApiCoreV1Pod; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpodephemeralcontainers, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedpodeviction = ( + id = "createCoreV1NamespacedPodEviction", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/eviction", + parameters = ((arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/2/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/3/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/4/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/parameters/5/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiPolicyV1Eviction, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1eviction/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedpodeviction(...)\n\ncreate eviction of a Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/eviction`" +function createcorev1namespacedpodeviction(namespace::String, name::String, body::IoK8sApiPolicyV1Eviction; dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_createcorev1namespacedpodeviction, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedpodexec = ( + id = "connectCoreV1GetNamespacedPodExec", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/exec", + parameters = ((arg = :command, name = "command", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/0/schema"), content = (), required = false),(arg = :container, name = "container", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/1/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/2/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/3/schema"), content = (), required = true),(arg = :stderr, name = "stderr", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/4/schema"), content = (), required = false),(arg = :stdin, name = "stdin", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/5/schema"), content = (), required = false),(arg = :stdout, name = "stdout", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/6/schema"), content = (), required = false),(arg = :tty, name = "tty", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/7/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedpodexec(...)\n\nconnect GET requests to exec of Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/exec`" +function connectcorev1getnamespacedpodexec(namespace::String, name::String; command::Union{Absent,String} = ABSENT, container::Union{Absent,String} = ABSENT, stderr::Union{Absent,Bool} = ABSENT, stdin::Union{Absent,Bool} = ABSENT, stdout::Union{Absent,Bool} = ABSENT, tty::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:command] = command + _openapi_values[:container] = container + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:stderr] = stderr + _openapi_values[:stdin] = stdin + _openapi_values[:stdout] = stdout + _openapi_values[:tty] = tty + return _request(client, _OP_connectcorev1getnamespacedpodexec, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedpodexec = ( + id = "connectCoreV1PostNamespacedPodExec", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/exec", + parameters = ((arg = :command, name = "command", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/0/schema"), content = (), required = false),(arg = :container, name = "container", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/1/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/2/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/3/schema"), content = (), required = true),(arg = :stderr, name = "stderr", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/4/schema"), content = (), required = false),(arg = :stdin, name = "stdin", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/5/schema"), content = (), required = false),(arg = :stdout, name = "stdout", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/6/schema"), content = (), required = false),(arg = :tty, name = "tty", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/parameters/7/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1exec/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedpodexec(...)\n\nconnect POST requests to exec of Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/exec`" +function connectcorev1postnamespacedpodexec(namespace::String, name::String; command::Union{Absent,String} = ABSENT, container::Union{Absent,String} = ABSENT, stderr::Union{Absent,Bool} = ABSENT, stdin::Union{Absent,Bool} = ABSENT, stdout::Union{Absent,Bool} = ABSENT, tty::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:command] = command + _openapi_values[:container] = container + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:stderr] = stderr + _openapi_values[:stdin] = stdin + _openapi_values[:stdout] = stdout + _openapi_values[:tty] = tty + return _request(client, _OP_connectcorev1postnamespacedpodexec, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpodlog = ( + id = "readCoreV1NamespacedPodLog", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/log", + parameters = ((arg = :container, name = "container", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/0/schema"), content = (), required = false),(arg = :follow, name = "follow", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/1/schema"), content = (), required = false),(arg = :insecureskiptlsverifybackend, name = "insecureSkipTLSVerifyBackend", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/2/schema"), content = (), required = false),(arg = :limitbytes, name = "limitBytes", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/3/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/4/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/6/schema"), content = (), required = false),(arg = :previous, name = "previous", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/7/schema"), content = (), required = false),(arg = :sinceseconds, name = "sinceSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/8/schema"), content = (), required = false),(arg = :stream, name = "stream", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/9/schema"), content = (), required = false),(arg = :taillines, name = "tailLines", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/10/schema"), content = (), required = false),(arg = :timestamps, name = "timestamps", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/application~1yaml/schema"), (), ()),("text/plain", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1log/get/responses/200/content/text~1plain/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpodlog(...)\n\nread log of the specified Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/log`" +function readcorev1namespacedpodlog(namespace::String, name::String; container::Union{Absent,String} = ABSENT, follow::Union{Absent,Bool} = ABSENT, insecureskiptlsverifybackend::Union{Absent,Bool} = ABSENT, limitbytes::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, previous::Union{Absent,Bool} = ABSENT, sinceseconds::Union{Absent,Int64} = ABSENT, stream::Union{Absent,String} = ABSENT, taillines::Union{Absent,Int64} = ABSENT, timestamps::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:container] = container + _openapi_values[:follow] = follow + _openapi_values[:insecureskiptlsverifybackend] = insecureskiptlsverifybackend + _openapi_values[:limitbytes] = limitbytes + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:previous] = previous + _openapi_values[:sinceseconds] = sinceseconds + _openapi_values[:stream] = stream + _openapi_values[:taillines] = taillines + _openapi_values[:timestamps] = timestamps + return _request(client, _OP_readcorev1namespacedpodlog, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedpodportforward = ( + id = "connectCoreV1GetNamespacedPodPortforward", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/portforward", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/1/schema"), content = (), required = true),(arg = :ports, name = "ports", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedpodportforward(...)\n\nconnect GET requests to portforward of Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/portforward`" +function connectcorev1getnamespacedpodportforward(namespace::String, name::String; ports::Union{Absent,Int64} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:ports] = ports + return _request(client, _OP_connectcorev1getnamespacedpodportforward, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedpodportforward = ( + id = "connectCoreV1PostNamespacedPodPortforward", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/portforward", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/1/schema"), content = (), required = true),(arg = :ports, name = "ports", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1portforward/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedpodportforward(...)\n\nconnect POST requests to portforward of Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/portforward`" +function connectcorev1postnamespacedpodportforward(namespace::String, name::String; ports::Union{Absent,Int64} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:ports] = ports + return _request(client, _OP_connectcorev1postnamespacedpodportforward, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenamespacedpodproxy = ( + id = "connectCoreV1DeleteNamespacedPodProxy", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenamespacedpodproxy(...)\n\nconnect DELETE requests to proxy of Pod\n\n`DELETE /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1deletenamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1deletenamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedpodproxy = ( + id = "connectCoreV1GetNamespacedPodProxy", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedpodproxy(...)\n\nconnect GET requests to proxy of Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1getnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1getnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnamespacedpodproxy = ( + id = "connectCoreV1HeadNamespacedPodProxy", + method = "HEAD", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnamespacedpodproxy(...)\n\nconnect HEAD requests to proxy of Pod\n\n`HEAD /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1headnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1headnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnamespacedpodproxy = ( + id = "connectCoreV1OptionsNamespacedPodProxy", + method = "OPTIONS", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnamespacedpodproxy(...)\n\nconnect OPTIONS requests to proxy of Pod\n\n`OPTIONS /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1optionsnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1optionsnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnamespacedpodproxy = ( + id = "connectCoreV1PatchNamespacedPodProxy", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnamespacedpodproxy(...)\n\nconnect PATCH requests to proxy of Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1patchnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1patchnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedpodproxy = ( + id = "connectCoreV1PostNamespacedPodProxy", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedpodproxy(...)\n\nconnect POST requests to proxy of Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1postnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1postnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnamespacedpodproxy = ( + id = "connectCoreV1PutNamespacedPodProxy", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnamespacedpodproxy(...)\n\nconnect PUT requests to proxy of Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}/proxy`" +function connectcorev1putnamespacedpodproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1putnamespacedpodproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenamespacedpodproxywithpath = ( + id = "connectCoreV1DeleteNamespacedPodProxyWithPath", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenamespacedpodproxywithpath(...)\n\nconnect DELETE requests to proxy of Pod\n\n`DELETE /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1deletenamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1deletenamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedpodproxywithpath = ( + id = "connectCoreV1GetNamespacedPodProxyWithPath", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedpodproxywithpath(...)\n\nconnect GET requests to proxy of Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1getnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1getnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnamespacedpodproxywithpath = ( + id = "connectCoreV1HeadNamespacedPodProxyWithPath", + method = "HEAD", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnamespacedpodproxywithpath(...)\n\nconnect HEAD requests to proxy of Pod\n\n`HEAD /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1headnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1headnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnamespacedpodproxywithpath = ( + id = "connectCoreV1OptionsNamespacedPodProxyWithPath", + method = "OPTIONS", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnamespacedpodproxywithpath(...)\n\nconnect OPTIONS requests to proxy of Pod\n\n`OPTIONS /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1optionsnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1optionsnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnamespacedpodproxywithpath = ( + id = "connectCoreV1PatchNamespacedPodProxyWithPath", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnamespacedpodproxywithpath(...)\n\nconnect PATCH requests to proxy of Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1patchnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1patchnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedpodproxywithpath = ( + id = "connectCoreV1PostNamespacedPodProxyWithPath", + method = "POST", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedpodproxywithpath(...)\n\nconnect POST requests to proxy of Pod\n\n`POST /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1postnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1postnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnamespacedpodproxywithpath = ( + id = "connectCoreV1PutNamespacedPodProxyWithPath", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnamespacedpodproxywithpath(...)\n\nconnect PUT requests to proxy of Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}/proxy/{path}`" +function connectcorev1putnamespacedpodproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1putnamespacedpodproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpodresize = ( + id = "readCoreV1NamespacedPodResize", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/resize", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpodresize(...)\n\nread resize of the specified Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/resize`" +function readcorev1namespacedpodresize(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedpodresize, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpodresize = ( + id = "patchCoreV1NamespacedPodResize", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}/resize", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpodresize(...)\n\npartially update resize of the specified Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}/resize`" +function patchcorev1namespacedpodresize(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpodresize, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpodresize = ( + id = "replaceCoreV1NamespacedPodResize", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}/resize", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1resize/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpodresize(...)\n\nreplace resize of the specified Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}/resize`" +function replacecorev1namespacedpodresize(namespace::String, name::String, body::IoK8sApiCoreV1Pod; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpodresize, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpodstatus = ( + id = "readCoreV1NamespacedPodStatus", + method = "GET", + path = "/api/v1/namespaces/{namespace}/pods/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpodstatus(...)\n\nread status of the specified Pod\n\n`GET /api/v1/namespaces/{namespace}/pods/{name}/status`" +function readcorev1namespacedpodstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedpodstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpodstatus = ( + id = "patchCoreV1NamespacedPodStatus", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/pods/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpodstatus(...)\n\npartially update status of the specified Pod\n\n`PATCH /api/v1/namespaces/{namespace}/pods/{name}/status`" +function patchcorev1namespacedpodstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpodstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpodstatus = ( + id = "replaceCoreV1NamespacedPodStatus", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/pods/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Pod, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1pods~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpodstatus(...)\n\nreplace status of the specified Pod\n\n`PUT /api/v1/namespaces/{namespace}/pods/{name}/status`" +function replacecorev1namespacedpodstatus(namespace::String, name::String, body::IoK8sApiCoreV1Pod; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpodstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedpodtemplate = ( + id = "deleteCoreV1CollectionNamespacedPodTemplate", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/podtemplates", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedpodtemplate(...)\n\ndelete collection of PodTemplate\n\n`DELETE /api/v1/namespaces/{namespace}/podtemplates`" +function deletecorev1collectionnamespacedpodtemplate(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedpodtemplate, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedpodtemplate = ( + id = "listCoreV1NamespacedPodTemplate", + method = "GET", + path = "/api/v1/namespaces/{namespace}/podtemplates", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedpodtemplate(...)\n\nlist or watch objects of kind PodTemplate\n\n`GET /api/v1/namespaces/{namespace}/podtemplates`" +function listcorev1namespacedpodtemplate(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedpodtemplate, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedpodtemplate = ( + id = "createCoreV1NamespacedPodTemplate", + method = "POST", + path = "/api/v1/namespaces/{namespace}/podtemplates", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedpodtemplate(...)\n\ncreate a PodTemplate\n\n`POST /api/v1/namespaces/{namespace}/podtemplates`" +function createcorev1namespacedpodtemplate(namespace::String, body::IoK8sApiCoreV1PodTemplate; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedpodtemplate, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedpodtemplate = ( + id = "deleteCoreV1NamespacedPodTemplate", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/podtemplates/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedpodtemplate(...)\n\ndelete a PodTemplate\n\n`DELETE /api/v1/namespaces/{namespace}/podtemplates/{name}`" +function deletecorev1namespacedpodtemplate(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedpodtemplate, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedpodtemplate = ( + id = "readCoreV1NamespacedPodTemplate", + method = "GET", + path = "/api/v1/namespaces/{namespace}/podtemplates/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedpodtemplate(...)\n\nread the specified PodTemplate\n\n`GET /api/v1/namespaces/{namespace}/podtemplates/{name}`" +function readcorev1namespacedpodtemplate(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedpodtemplate, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedpodtemplate = ( + id = "patchCoreV1NamespacedPodTemplate", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/podtemplates/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedpodtemplate(...)\n\npartially update the specified PodTemplate\n\n`PATCH /api/v1/namespaces/{namespace}/podtemplates/{name}`" +function patchcorev1namespacedpodtemplate(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedpodtemplate, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedpodtemplate = ( + id = "replaceCoreV1NamespacedPodTemplate", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/podtemplates/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplate, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1podtemplates~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedpodtemplate(...)\n\nreplace the specified PodTemplate\n\n`PUT /api/v1/namespaces/{namespace}/podtemplates/{name}`" +function replacecorev1namespacedpodtemplate(namespace::String, name::String, body::IoK8sApiCoreV1PodTemplate; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedpodtemplate, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedreplicationcontroller = ( + id = "deleteCoreV1CollectionNamespacedReplicationController", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedreplicationcontroller(...)\n\ndelete collection of ReplicationController\n\n`DELETE /api/v1/namespaces/{namespace}/replicationcontrollers`" +function deletecorev1collectionnamespacedreplicationcontroller(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedreplicationcontroller, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedreplicationcontroller = ( + id = "listCoreV1NamespacedReplicationController", + method = "GET", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedreplicationcontroller(...)\n\nlist or watch objects of kind ReplicationController\n\n`GET /api/v1/namespaces/{namespace}/replicationcontrollers`" +function listcorev1namespacedreplicationcontroller(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedreplicationcontroller, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedreplicationcontroller = ( + id = "createCoreV1NamespacedReplicationController", + method = "POST", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedreplicationcontroller(...)\n\ncreate a ReplicationController\n\n`POST /api/v1/namespaces/{namespace}/replicationcontrollers`" +function createcorev1namespacedreplicationcontroller(namespace::String, body::IoK8sApiCoreV1ReplicationController; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedreplicationcontroller, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedreplicationcontroller = ( + id = "deleteCoreV1NamespacedReplicationController", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedreplicationcontroller(...)\n\ndelete a ReplicationController\n\n`DELETE /api/v1/namespaces/{namespace}/replicationcontrollers/{name}`" +function deletecorev1namespacedreplicationcontroller(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedreplicationcontroller, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedreplicationcontroller = ( + id = "readCoreV1NamespacedReplicationController", + method = "GET", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedreplicationcontroller(...)\n\nread the specified ReplicationController\n\n`GET /api/v1/namespaces/{namespace}/replicationcontrollers/{name}`" +function readcorev1namespacedreplicationcontroller(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedreplicationcontroller, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedreplicationcontroller = ( + id = "patchCoreV1NamespacedReplicationController", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedreplicationcontroller(...)\n\npartially update the specified ReplicationController\n\n`PATCH /api/v1/namespaces/{namespace}/replicationcontrollers/{name}`" +function patchcorev1namespacedreplicationcontroller(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedreplicationcontroller, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedreplicationcontroller = ( + id = "replaceCoreV1NamespacedReplicationController", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedreplicationcontroller(...)\n\nreplace the specified ReplicationController\n\n`PUT /api/v1/namespaces/{namespace}/replicationcontrollers/{name}`" +function replacecorev1namespacedreplicationcontroller(namespace::String, name::String, body::IoK8sApiCoreV1ReplicationController; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedreplicationcontroller, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedreplicationcontrollerscale = ( + id = "readCoreV1NamespacedReplicationControllerScale", + method = "GET", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedreplicationcontrollerscale(...)\n\nread scale of the specified ReplicationController\n\n`GET /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale`" +function readcorev1namespacedreplicationcontrollerscale(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedreplicationcontrollerscale, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedreplicationcontrollerscale = ( + id = "patchCoreV1NamespacedReplicationControllerScale", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedreplicationcontrollerscale(...)\n\npartially update scale of the specified ReplicationController\n\n`PATCH /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale`" +function patchcorev1namespacedreplicationcontrollerscale(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedreplicationcontrollerscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedreplicationcontrollerscale = ( + id = "replaceCoreV1NamespacedReplicationControllerScale", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAutoscalingV1Scale, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1scale/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedreplicationcontrollerscale(...)\n\nreplace scale of the specified ReplicationController\n\n`PUT /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale`" +function replacecorev1namespacedreplicationcontrollerscale(namespace::String, name::String, body::IoK8sApiAutoscalingV1Scale; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedreplicationcontrollerscale, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedreplicationcontrollerstatus = ( + id = "readCoreV1NamespacedReplicationControllerStatus", + method = "GET", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedreplicationcontrollerstatus(...)\n\nread status of the specified ReplicationController\n\n`GET /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status`" +function readcorev1namespacedreplicationcontrollerstatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedreplicationcontrollerstatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedreplicationcontrollerstatus = ( + id = "patchCoreV1NamespacedReplicationControllerStatus", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedreplicationcontrollerstatus(...)\n\npartially update status of the specified ReplicationController\n\n`PATCH /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status`" +function patchcorev1namespacedreplicationcontrollerstatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedreplicationcontrollerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedreplicationcontrollerstatus = ( + id = "replaceCoreV1NamespacedReplicationControllerStatus", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationController, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1replicationcontrollers~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedreplicationcontrollerstatus(...)\n\nreplace status of the specified ReplicationController\n\n`PUT /api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status`" +function replacecorev1namespacedreplicationcontrollerstatus(namespace::String, name::String, body::IoK8sApiCoreV1ReplicationController; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedreplicationcontrollerstatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedresourcequota = ( + id = "deleteCoreV1CollectionNamespacedResourceQuota", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/resourcequotas", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedresourcequota(...)\n\ndelete collection of ResourceQuota\n\n`DELETE /api/v1/namespaces/{namespace}/resourcequotas`" +function deletecorev1collectionnamespacedresourcequota(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedresourcequota, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedresourcequota = ( + id = "listCoreV1NamespacedResourceQuota", + method = "GET", + path = "/api/v1/namespaces/{namespace}/resourcequotas", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedresourcequota(...)\n\nlist or watch objects of kind ResourceQuota\n\n`GET /api/v1/namespaces/{namespace}/resourcequotas`" +function listcorev1namespacedresourcequota(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedresourcequota, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedresourcequota = ( + id = "createCoreV1NamespacedResourceQuota", + method = "POST", + path = "/api/v1/namespaces/{namespace}/resourcequotas", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedresourcequota(...)\n\ncreate a ResourceQuota\n\n`POST /api/v1/namespaces/{namespace}/resourcequotas`" +function createcorev1namespacedresourcequota(namespace::String, body::IoK8sApiCoreV1ResourceQuota; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedresourcequota, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedresourcequota = ( + id = "deleteCoreV1NamespacedResourceQuota", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedresourcequota(...)\n\ndelete a ResourceQuota\n\n`DELETE /api/v1/namespaces/{namespace}/resourcequotas/{name}`" +function deletecorev1namespacedresourcequota(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedresourcequota, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedresourcequota = ( + id = "readCoreV1NamespacedResourceQuota", + method = "GET", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedresourcequota(...)\n\nread the specified ResourceQuota\n\n`GET /api/v1/namespaces/{namespace}/resourcequotas/{name}`" +function readcorev1namespacedresourcequota(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedresourcequota, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedresourcequota = ( + id = "patchCoreV1NamespacedResourceQuota", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedresourcequota(...)\n\npartially update the specified ResourceQuota\n\n`PATCH /api/v1/namespaces/{namespace}/resourcequotas/{name}`" +function patchcorev1namespacedresourcequota(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedresourcequota, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedresourcequota = ( + id = "replaceCoreV1NamespacedResourceQuota", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedresourcequota(...)\n\nreplace the specified ResourceQuota\n\n`PUT /api/v1/namespaces/{namespace}/resourcequotas/{name}`" +function replacecorev1namespacedresourcequota(namespace::String, name::String, body::IoK8sApiCoreV1ResourceQuota; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedresourcequota, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedresourcequotastatus = ( + id = "readCoreV1NamespacedResourceQuotaStatus", + method = "GET", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedresourcequotastatus(...)\n\nread status of the specified ResourceQuota\n\n`GET /api/v1/namespaces/{namespace}/resourcequotas/{name}/status`" +function readcorev1namespacedresourcequotastatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedresourcequotastatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedresourcequotastatus = ( + id = "patchCoreV1NamespacedResourceQuotaStatus", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedresourcequotastatus(...)\n\npartially update status of the specified ResourceQuota\n\n`PATCH /api/v1/namespaces/{namespace}/resourcequotas/{name}/status`" +function patchcorev1namespacedresourcequotastatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedresourcequotastatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedresourcequotastatus = ( + id = "replaceCoreV1NamespacedResourceQuotaStatus", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/resourcequotas/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuota, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1resourcequotas~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedresourcequotastatus(...)\n\nreplace status of the specified ResourceQuota\n\n`PUT /api/v1/namespaces/{namespace}/resourcequotas/{name}/status`" +function replacecorev1namespacedresourcequotastatus(namespace::String, name::String, body::IoK8sApiCoreV1ResourceQuota; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedresourcequotastatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedsecret = ( + id = "deleteCoreV1CollectionNamespacedSecret", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/secrets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedsecret(...)\n\ndelete collection of Secret\n\n`DELETE /api/v1/namespaces/{namespace}/secrets`" +function deletecorev1collectionnamespacedsecret(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedsecret, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedsecret = ( + id = "listCoreV1NamespacedSecret", + method = "GET", + path = "/api/v1/namespaces/{namespace}/secrets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedsecret(...)\n\nlist or watch objects of kind Secret\n\n`GET /api/v1/namespaces/{namespace}/secrets`" +function listcorev1namespacedsecret(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedsecret, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedsecret = ( + id = "createCoreV1NamespacedSecret", + method = "POST", + path = "/api/v1/namespaces/{namespace}/secrets", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedsecret(...)\n\ncreate a Secret\n\n`POST /api/v1/namespaces/{namespace}/secrets`" +function createcorev1namespacedsecret(namespace::String, body::IoK8sApiCoreV1Secret; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedsecret, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedsecret = ( + id = "deleteCoreV1NamespacedSecret", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/secrets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedsecret(...)\n\ndelete a Secret\n\n`DELETE /api/v1/namespaces/{namespace}/secrets/{name}`" +function deletecorev1namespacedsecret(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedsecret, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedsecret = ( + id = "readCoreV1NamespacedSecret", + method = "GET", + path = "/api/v1/namespaces/{namespace}/secrets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedsecret(...)\n\nread the specified Secret\n\n`GET /api/v1/namespaces/{namespace}/secrets/{name}`" +function readcorev1namespacedsecret(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedsecret, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedsecret = ( + id = "patchCoreV1NamespacedSecret", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/secrets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedsecret(...)\n\npartially update the specified Secret\n\n`PATCH /api/v1/namespaces/{namespace}/secrets/{name}`" +function patchcorev1namespacedsecret(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedsecret, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedsecret = ( + id = "replaceCoreV1NamespacedSecret", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/secrets/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Secret, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1secrets~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedsecret(...)\n\nreplace the specified Secret\n\n`PUT /api/v1/namespaces/{namespace}/secrets/{name}`" +function replacecorev1namespacedsecret(namespace::String, name::String, body::IoK8sApiCoreV1Secret; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedsecret, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedserviceaccount = ( + id = "deleteCoreV1CollectionNamespacedServiceAccount", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/serviceaccounts", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedserviceaccount(...)\n\ndelete collection of ServiceAccount\n\n`DELETE /api/v1/namespaces/{namespace}/serviceaccounts`" +function deletecorev1collectionnamespacedserviceaccount(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedserviceaccount, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedserviceaccount = ( + id = "listCoreV1NamespacedServiceAccount", + method = "GET", + path = "/api/v1/namespaces/{namespace}/serviceaccounts", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedserviceaccount(...)\n\nlist or watch objects of kind ServiceAccount\n\n`GET /api/v1/namespaces/{namespace}/serviceaccounts`" +function listcorev1namespacedserviceaccount(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedserviceaccount, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedserviceaccount = ( + id = "createCoreV1NamespacedServiceAccount", + method = "POST", + path = "/api/v1/namespaces/{namespace}/serviceaccounts", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedserviceaccount(...)\n\ncreate a ServiceAccount\n\n`POST /api/v1/namespaces/{namespace}/serviceaccounts`" +function createcorev1namespacedserviceaccount(namespace::String, body::IoK8sApiCoreV1ServiceAccount; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedserviceaccount, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedserviceaccount = ( + id = "deleteCoreV1NamespacedServiceAccount", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedserviceaccount(...)\n\ndelete a ServiceAccount\n\n`DELETE /api/v1/namespaces/{namespace}/serviceaccounts/{name}`" +function deletecorev1namespacedserviceaccount(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedserviceaccount, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedserviceaccount = ( + id = "readCoreV1NamespacedServiceAccount", + method = "GET", + path = "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedserviceaccount(...)\n\nread the specified ServiceAccount\n\n`GET /api/v1/namespaces/{namespace}/serviceaccounts/{name}`" +function readcorev1namespacedserviceaccount(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedserviceaccount, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedserviceaccount = ( + id = "patchCoreV1NamespacedServiceAccount", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedserviceaccount(...)\n\npartially update the specified ServiceAccount\n\n`PATCH /api/v1/namespaces/{namespace}/serviceaccounts/{name}`" +function patchcorev1namespacedserviceaccount(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedserviceaccount, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedserviceaccount = ( + id = "replaceCoreV1NamespacedServiceAccount", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/serviceaccounts/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccount, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedserviceaccount(...)\n\nreplace the specified ServiceAccount\n\n`PUT /api/v1/namespaces/{namespace}/serviceaccounts/{name}`" +function replacecorev1namespacedserviceaccount(namespace::String, name::String, body::IoK8sApiCoreV1ServiceAccount; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedserviceaccount, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedserviceaccounttoken = ( + id = "createCoreV1NamespacedServiceAccountToken", + method = "POST", + path = "/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token", + parameters = ((arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/2/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/3/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/4/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/parameters/5/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiAuthenticationV1TokenRequest, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1serviceaccounts~1{name}~1token/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedserviceaccounttoken(...)\n\ncreate token of a ServiceAccount\n\n`POST /api/v1/namespaces/{namespace}/serviceaccounts/{name}/token`" +function createcorev1namespacedserviceaccounttoken(namespace::String, name::String, body::IoK8sApiAuthenticationV1TokenRequest; dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_createcorev1namespacedserviceaccounttoken, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnamespacedservice = ( + id = "deleteCoreV1CollectionNamespacedService", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/services", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/1/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnamespacedservice(...)\n\ndelete collection of Service\n\n`DELETE /api/v1/namespaces/{namespace}/services`" +function deletecorev1collectionnamespacedservice(namespace::String; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnamespacedservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1namespacedservice = ( + id = "listCoreV1NamespacedService", + method = "GET", + path = "/api/v1/namespaces/{namespace}/services", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/1/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1namespacedservice(...)\n\nlist or watch objects of kind Service\n\n`GET /api/v1/namespaces/{namespace}/services`" +function listcorev1namespacedservice(namespace::String; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1namespacedservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1namespacedservice = ( + id = "createCoreV1NamespacedService", + method = "POST", + path = "/api/v1/namespaces/{namespace}/services", + parameters = ((arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1namespacedservice(...)\n\ncreate a Service\n\n`POST /api/v1/namespaces/{namespace}/services`" +function createcorev1namespacedservice(namespace::String, body::IoK8sApiCoreV1Service; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1namespacedservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespacedservice = ( + id = "deleteCoreV1NamespacedService", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/services/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespacedservice(...)\n\ndelete a Service\n\n`DELETE /api/v1/namespaces/{namespace}/services/{name}`" +function deletecorev1namespacedservice(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespacedservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedservice = ( + id = "readCoreV1NamespacedService", + method = "GET", + path = "/api/v1/namespaces/{namespace}/services/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedservice(...)\n\nread the specified Service\n\n`GET /api/v1/namespaces/{namespace}/services/{name}`" +function readcorev1namespacedservice(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespacedservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedservice = ( + id = "patchCoreV1NamespacedService", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/services/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedservice(...)\n\npartially update the specified Service\n\n`PATCH /api/v1/namespaces/{namespace}/services/{name}`" +function patchcorev1namespacedservice(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedservice = ( + id = "replaceCoreV1NamespacedService", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/services/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedservice(...)\n\nreplace the specified Service\n\n`PUT /api/v1/namespaces/{namespace}/services/{name}`" +function replacecorev1namespacedservice(namespace::String, name::String, body::IoK8sApiCoreV1Service; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedservice, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenamespacedserviceproxy = ( + id = "connectCoreV1DeleteNamespacedServiceProxy", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenamespacedserviceproxy(...)\n\nconnect DELETE requests to proxy of Service\n\n`DELETE /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1deletenamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1deletenamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedserviceproxy = ( + id = "connectCoreV1GetNamespacedServiceProxy", + method = "GET", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedserviceproxy(...)\n\nconnect GET requests to proxy of Service\n\n`GET /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1getnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1getnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnamespacedserviceproxy = ( + id = "connectCoreV1HeadNamespacedServiceProxy", + method = "HEAD", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnamespacedserviceproxy(...)\n\nconnect HEAD requests to proxy of Service\n\n`HEAD /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1headnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1headnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnamespacedserviceproxy = ( + id = "connectCoreV1OptionsNamespacedServiceProxy", + method = "OPTIONS", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnamespacedserviceproxy(...)\n\nconnect OPTIONS requests to proxy of Service\n\n`OPTIONS /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1optionsnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1optionsnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnamespacedserviceproxy = ( + id = "connectCoreV1PatchNamespacedServiceProxy", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnamespacedserviceproxy(...)\n\nconnect PATCH requests to proxy of Service\n\n`PATCH /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1patchnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1patchnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedserviceproxy = ( + id = "connectCoreV1PostNamespacedServiceProxy", + method = "POST", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedserviceproxy(...)\n\nconnect POST requests to proxy of Service\n\n`POST /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1postnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1postnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnamespacedserviceproxy = ( + id = "connectCoreV1PutNamespacedServiceProxy", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnamespacedserviceproxy(...)\n\nconnect PUT requests to proxy of Service\n\n`PUT /api/v1/namespaces/{namespace}/services/{name}/proxy`" +function connectcorev1putnamespacedserviceproxy(namespace::String, name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1putnamespacedserviceproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenamespacedserviceproxywithpath = ( + id = "connectCoreV1DeleteNamespacedServiceProxyWithPath", + method = "DELETE", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenamespacedserviceproxywithpath(...)\n\nconnect DELETE requests to proxy of Service\n\n`DELETE /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1deletenamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1deletenamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnamespacedserviceproxywithpath = ( + id = "connectCoreV1GetNamespacedServiceProxyWithPath", + method = "GET", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnamespacedserviceproxywithpath(...)\n\nconnect GET requests to proxy of Service\n\n`GET /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1getnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1getnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnamespacedserviceproxywithpath = ( + id = "connectCoreV1HeadNamespacedServiceProxyWithPath", + method = "HEAD", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnamespacedserviceproxywithpath(...)\n\nconnect HEAD requests to proxy of Service\n\n`HEAD /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1headnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1headnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnamespacedserviceproxywithpath = ( + id = "connectCoreV1OptionsNamespacedServiceProxyWithPath", + method = "OPTIONS", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnamespacedserviceproxywithpath(...)\n\nconnect OPTIONS requests to proxy of Service\n\n`OPTIONS /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1optionsnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1optionsnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnamespacedserviceproxywithpath = ( + id = "connectCoreV1PatchNamespacedServiceProxyWithPath", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnamespacedserviceproxywithpath(...)\n\nconnect PATCH requests to proxy of Service\n\n`PATCH /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1patchnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1patchnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnamespacedserviceproxywithpath = ( + id = "connectCoreV1PostNamespacedServiceProxyWithPath", + method = "POST", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnamespacedserviceproxywithpath(...)\n\nconnect POST requests to proxy of Service\n\n`POST /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1postnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1postnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnamespacedserviceproxywithpath = ( + id = "connectCoreV1PutNamespacedServiceProxyWithPath", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/services/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/parameters/3/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnamespacedserviceproxywithpath(...)\n\nconnect PUT requests to proxy of Service\n\n`PUT /api/v1/namespaces/{namespace}/services/{name}/proxy/{path}`" +function connectcorev1putnamespacedserviceproxywithpath(namespace::String, name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1putnamespacedserviceproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacedservicestatus = ( + id = "readCoreV1NamespacedServiceStatus", + method = "GET", + path = "/api/v1/namespaces/{namespace}/services/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacedservicestatus(...)\n\nread status of the specified Service\n\n`GET /api/v1/namespaces/{namespace}/services/{name}/status`" +function readcorev1namespacedservicestatus(namespace::String, name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacedservicestatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacedservicestatus = ( + id = "patchCoreV1NamespacedServiceStatus", + method = "PATCH", + path = "/api/v1/namespaces/{namespace}/services/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacedservicestatus(...)\n\npartially update status of the specified Service\n\n`PATCH /api/v1/namespaces/{namespace}/services/{name}/status`" +function patchcorev1namespacedservicestatus(namespace::String, name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacedservicestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacedservicestatus = ( + id = "replaceCoreV1NamespacedServiceStatus", + method = "PUT", + path = "/api/v1/namespaces/{namespace}/services/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/1/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/parameters/2/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Service, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{namespace}~1services~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacedservicestatus(...)\n\nreplace status of the specified Service\n\n`PUT /api/v1/namespaces/{namespace}/services/{name}/status`" +function replacecorev1namespacedservicestatus(namespace::String, name::String, body::IoK8sApiCoreV1Service; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacedservicestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1namespace = ( + id = "deleteCoreV1Namespace", + method = "DELETE", + path = "/api/v1/namespaces/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1namespace(...)\n\ndelete a Namespace\n\n`DELETE /api/v1/namespaces/{name}`" +function deletecorev1namespace(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1namespace, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespace = ( + id = "readCoreV1Namespace", + method = "GET", + path = "/api/v1/namespaces/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespace(...)\n\nread the specified Namespace\n\n`GET /api/v1/namespaces/{name}`" +function readcorev1namespace(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1namespace, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespace = ( + id = "patchCoreV1Namespace", + method = "PATCH", + path = "/api/v1/namespaces/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespace(...)\n\npartially update the specified Namespace\n\n`PATCH /api/v1/namespaces/{name}`" +function patchcorev1namespace(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespace, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespace = ( + id = "replaceCoreV1Namespace", + method = "PUT", + path = "/api/v1/namespaces/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespace(...)\n\nreplace the specified Namespace\n\n`PUT /api/v1/namespaces/{name}`" +function replacecorev1namespace(name::String, body::IoK8sApiCoreV1Namespace; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespace, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacefinalize = ( + id = "replaceCoreV1NamespaceFinalize", + method = "PUT", + path = "/api/v1/namespaces/{name}/finalize", + parameters = ((arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/2/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/3/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/parameters/4/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1finalize/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacefinalize(...)\n\nreplace finalize of the specified Namespace\n\n`PUT /api/v1/namespaces/{name}/finalize`" +function replacecorev1namespacefinalize(name::String, body::IoK8sApiCoreV1Namespace; dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_replacecorev1namespacefinalize, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1namespacestatus = ( + id = "readCoreV1NamespaceStatus", + method = "GET", + path = "/api/v1/namespaces/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1namespacestatus(...)\n\nread status of the specified Namespace\n\n`GET /api/v1/namespaces/{name}/status`" +function readcorev1namespacestatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1namespacestatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1namespacestatus = ( + id = "patchCoreV1NamespaceStatus", + method = "PATCH", + path = "/api/v1/namespaces/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1namespacestatus(...)\n\npartially update status of the specified Namespace\n\n`PATCH /api/v1/namespaces/{name}/status`" +function patchcorev1namespacestatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1namespacestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1namespacestatus = ( + id = "replaceCoreV1NamespaceStatus", + method = "PUT", + path = "/api/v1/namespaces/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Namespace, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1namespaces~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1namespacestatus(...)\n\nreplace status of the specified Namespace\n\n`PUT /api/v1/namespaces/{name}/status`" +function replacecorev1namespacestatus(name::String, body::IoK8sApiCoreV1Namespace; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1namespacestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionnode = ( + id = "deleteCoreV1CollectionNode", + method = "DELETE", + path = "/api/v1/nodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionnode(...)\n\ndelete collection of Node\n\n`DELETE /api/v1/nodes`" +function deletecorev1collectionnode(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionnode, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1node = ( + id = "listCoreV1Node", + method = "GET", + path = "/api/v1/nodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1NodeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1node(...)\n\nlist or watch objects of kind Node\n\n`GET /api/v1/nodes`" +function listcorev1node(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1node, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1node = ( + id = "createCoreV1Node", + method = "POST", + path = "/api/v1/nodes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1node(...)\n\ncreate a Node\n\n`POST /api/v1/nodes`" +function createcorev1node(body::IoK8sApiCoreV1Node; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1node, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1node = ( + id = "deleteCoreV1Node", + method = "DELETE", + path = "/api/v1/nodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1node(...)\n\ndelete a Node\n\n`DELETE /api/v1/nodes/{name}`" +function deletecorev1node(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1node, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1node = ( + id = "readCoreV1Node", + method = "GET", + path = "/api/v1/nodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1node(...)\n\nread the specified Node\n\n`GET /api/v1/nodes/{name}`" +function readcorev1node(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1node, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1node = ( + id = "patchCoreV1Node", + method = "PATCH", + path = "/api/v1/nodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1node(...)\n\npartially update the specified Node\n\n`PATCH /api/v1/nodes/{name}`" +function patchcorev1node(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1node, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1node = ( + id = "replaceCoreV1Node", + method = "PUT", + path = "/api/v1/nodes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1node(...)\n\nreplace the specified Node\n\n`PUT /api/v1/nodes/{name}`" +function replacecorev1node(name::String, body::IoK8sApiCoreV1Node; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1node, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenodeproxy = ( + id = "connectCoreV1DeleteNodeProxy", + method = "DELETE", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenodeproxy(...)\n\nconnect DELETE requests to proxy of Node\n\n`DELETE /api/v1/nodes/{name}/proxy`" +function connectcorev1deletenodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1deletenodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnodeproxy = ( + id = "connectCoreV1GetNodeProxy", + method = "GET", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnodeproxy(...)\n\nconnect GET requests to proxy of Node\n\n`GET /api/v1/nodes/{name}/proxy`" +function connectcorev1getnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1getnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnodeproxy = ( + id = "connectCoreV1HeadNodeProxy", + method = "HEAD", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnodeproxy(...)\n\nconnect HEAD requests to proxy of Node\n\n`HEAD /api/v1/nodes/{name}/proxy`" +function connectcorev1headnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1headnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnodeproxy = ( + id = "connectCoreV1OptionsNodeProxy", + method = "OPTIONS", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnodeproxy(...)\n\nconnect OPTIONS requests to proxy of Node\n\n`OPTIONS /api/v1/nodes/{name}/proxy`" +function connectcorev1optionsnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1optionsnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnodeproxy = ( + id = "connectCoreV1PatchNodeProxy", + method = "PATCH", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnodeproxy(...)\n\nconnect PATCH requests to proxy of Node\n\n`PATCH /api/v1/nodes/{name}/proxy`" +function connectcorev1patchnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1patchnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnodeproxy = ( + id = "connectCoreV1PostNodeProxy", + method = "POST", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnodeproxy(...)\n\nconnect POST requests to proxy of Node\n\n`POST /api/v1/nodes/{name}/proxy`" +function connectcorev1postnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1postnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnodeproxy = ( + id = "connectCoreV1PutNodeProxy", + method = "PUT", + path = "/api/v1/nodes/{name}/proxy", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnodeproxy(...)\n\nconnect PUT requests to proxy of Node\n\n`PUT /api/v1/nodes/{name}/proxy`" +function connectcorev1putnodeproxy(name::String; path::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + return _request(client, _OP_connectcorev1putnodeproxy, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1deletenodeproxywithpath = ( + id = "connectCoreV1DeleteNodeProxyWithPath", + method = "DELETE", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/delete/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1deletenodeproxywithpath(...)\n\nconnect DELETE requests to proxy of Node\n\n`DELETE /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1deletenodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1deletenodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1getnodeproxywithpath = ( + id = "connectCoreV1GetNodeProxyWithPath", + method = "GET", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/get/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1getnodeproxywithpath(...)\n\nconnect GET requests to proxy of Node\n\n`GET /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1getnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1getnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1headnodeproxywithpath = ( + id = "connectCoreV1HeadNodeProxyWithPath", + method = "HEAD", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/head/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1headnodeproxywithpath(...)\n\nconnect HEAD requests to proxy of Node\n\n`HEAD /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1headnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1headnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1optionsnodeproxywithpath = ( + id = "connectCoreV1OptionsNodeProxyWithPath", + method = "OPTIONS", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/options/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1optionsnodeproxywithpath(...)\n\nconnect OPTIONS requests to proxy of Node\n\n`OPTIONS /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1optionsnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1optionsnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1patchnodeproxywithpath = ( + id = "connectCoreV1PatchNodeProxyWithPath", + method = "PATCH", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/patch/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1patchnodeproxywithpath(...)\n\nconnect PATCH requests to proxy of Node\n\n`PATCH /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1patchnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1patchnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1postnodeproxywithpath = ( + id = "connectCoreV1PostNodeProxyWithPath", + method = "POST", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/post/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1postnodeproxywithpath(...)\n\nconnect POST requests to proxy of Node\n\n`POST /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1postnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1postnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_connectcorev1putnodeproxywithpath = ( + id = "connectCoreV1PutNodeProxyWithPath", + method = "PUT", + path = "/api/v1/nodes/{name}/proxy/{path}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/0/schema"), content = (), required = true),(arg = :path, name = "path", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/1/schema"), content = (), required = true),(arg = :path_2, name = "path", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/parameters/2/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("*/*", String, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1proxy~1{path}/put/responses/200/content/*~1*/schema"), (), ()),), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " connectcorev1putnodeproxywithpath(...)\n\nconnect PUT requests to proxy of Node\n\n`PUT /api/v1/nodes/{name}/proxy/{path}`" +function connectcorev1putnodeproxywithpath(name::String, path::String; path_2::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:path] = path + _openapi_values[:path_2] = path_2 + return _request(client, _OP_connectcorev1putnodeproxywithpath, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1nodestatus = ( + id = "readCoreV1NodeStatus", + method = "GET", + path = "/api/v1/nodes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1nodestatus(...)\n\nread status of the specified Node\n\n`GET /api/v1/nodes/{name}/status`" +function readcorev1nodestatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1nodestatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1nodestatus = ( + id = "patchCoreV1NodeStatus", + method = "PATCH", + path = "/api/v1/nodes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1nodestatus(...)\n\npartially update status of the specified Node\n\n`PATCH /api/v1/nodes/{name}/status`" +function patchcorev1nodestatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1nodestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1nodestatus = ( + id = "replaceCoreV1NodeStatus", + method = "PUT", + path = "/api/v1/nodes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1Node, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1nodes~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1nodestatus(...)\n\nreplace status of the specified Node\n\n`PUT /api/v1/nodes/{name}/status`" +function replacecorev1nodestatus(name::String, body::IoK8sApiCoreV1Node; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1nodestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1persistentvolumeclaimforallnamespaces = ( + id = "listCoreV1PersistentVolumeClaimForAllNamespaces", + method = "GET", + path = "/api/v1/persistentvolumeclaims", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeClaimList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1persistentvolumeclaimforallnamespaces(...)\n\nlist or watch objects of kind PersistentVolumeClaim\n\n`GET /api/v1/persistentvolumeclaims`" +function listcorev1persistentvolumeclaimforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1persistentvolumeclaimforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1collectionpersistentvolume = ( + id = "deleteCoreV1CollectionPersistentVolume", + method = "DELETE", + path = "/api/v1/persistentvolumes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/2/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/3/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/4/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/5/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/6/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/7/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/8/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/9/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/10/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/11/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/parameters/12/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1collectionpersistentvolume(...)\n\ndelete collection of PersistentVolume\n\n`DELETE /api/v1/persistentvolumes`" +function deletecorev1collectionpersistentvolume(; pretty::Union{Absent,String} = ABSENT, continue_::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:continue_] = continue_ + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + return _request(client, _OP_deletecorev1collectionpersistentvolume, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1persistentvolume = ( + id = "listCoreV1PersistentVolume", + method = "GET", + path = "/api/v1/persistentvolumes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/parameters/0/schema"), content = (), required = false),(arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/4/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/5/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/6/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/7/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/8/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/parameters/9/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolumeList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1persistentvolume(...)\n\nlist or watch objects of kind PersistentVolume\n\n`GET /api/v1/persistentvolumes`" +function listcorev1persistentvolume(; pretty::Union{Absent,String} = ABSENT, allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1persistentvolume, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_createcorev1persistentvolume = ( + id = "createCoreV1PersistentVolume", + method = "POST", + path = "/api/v1/persistentvolumes", + parameters = ((arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/parameters/0/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes/post/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " createcorev1persistentvolume(...)\n\ncreate a PersistentVolume\n\n`POST /api/v1/persistentvolumes`" +function createcorev1persistentvolume(body::IoK8sApiCoreV1PersistentVolume; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_createcorev1persistentvolume, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_deletecorev1persistentvolume = ( + id = "deleteCoreV1PersistentVolume", + method = "DELETE", + path = "/api/v1/persistentvolumes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/0/schema"), content = (), required = false),(arg = :graceperiodseconds, name = "gracePeriodSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/1/schema"), content = (), required = false),(arg = :ignorestorereaderrorwithclusterbreakingpotential, name = "ignoreStoreReadErrorWithClusterBreakingPotential", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/2/schema"), content = (), required = false),(arg = :orphandependents, name = "orphanDependents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/3/schema"), content = (), required = false),(arg = :propagationpolicy, name = "propagationPolicy", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/parameters/4/schema"), content = (), required = false)), + request = (required = false, media = (("application/json", IoK8sApimachineryPkgApisMetaV1DeleteOptions, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "202", media = (("application/cbor", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1cbor/schema"), (), ()),("application/json", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", Any, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/delete/responses/202/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " deletecorev1persistentvolume(...)\n\ndelete a PersistentVolume\n\n`DELETE /api/v1/persistentvolumes/{name}`" +function deletecorev1persistentvolume(name::String; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, graceperiodseconds::Union{Absent,Int64} = ABSENT, ignorestorereaderrorwithclusterbreakingpotential::Union{Absent,Bool} = ABSENT, orphandependents::Union{Absent,Bool} = ABSENT, propagationpolicy::Union{Absent,String} = ABSENT, body::Union{Absent,IoK8sApimachineryPkgApisMetaV1DeleteOptions} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:graceperiodseconds] = graceperiodseconds + _openapi_values[:ignorestorereaderrorwithclusterbreakingpotential] = ignorestorereaderrorwithclusterbreakingpotential + _openapi_values[:orphandependents] = orphandependents + _openapi_values[:propagationpolicy] = propagationpolicy + return _request(client, _OP_deletecorev1persistentvolume, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1persistentvolume = ( + id = "readCoreV1PersistentVolume", + method = "GET", + path = "/api/v1/persistentvolumes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/parameters/0/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1persistentvolume(...)\n\nread the specified PersistentVolume\n\n`GET /api/v1/persistentvolumes/{name}`" +function readcorev1persistentvolume(name::String; pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + return _request(client, _OP_readcorev1persistentvolume, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1persistentvolume = ( + id = "patchCoreV1PersistentVolume", + method = "PATCH", + path = "/api/v1/persistentvolumes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1persistentvolume(...)\n\npartially update the specified PersistentVolume\n\n`PATCH /api/v1/persistentvolumes/{name}`" +function patchcorev1persistentvolume(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1persistentvolume, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1persistentvolume = ( + id = "replaceCoreV1PersistentVolume", + method = "PUT", + path = "/api/v1/persistentvolumes/{name}", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1persistentvolume(...)\n\nreplace the specified PersistentVolume\n\n`PUT /api/v1/persistentvolumes/{name}`" +function replacecorev1persistentvolume(name::String, body::IoK8sApiCoreV1PersistentVolume; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1persistentvolume, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_readcorev1persistentvolumestatus = ( + id = "readCoreV1PersistentVolumeStatus", + method = "GET", + path = "/api/v1/persistentvolumes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/1/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " readcorev1persistentvolumestatus(...)\n\nread status of the specified PersistentVolume\n\n`GET /api/v1/persistentvolumes/{name}/status`" +function readcorev1persistentvolumestatus(name::String; pretty::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + return _request(client, _OP_readcorev1persistentvolumestatus, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_patchcorev1persistentvolumestatus = ( + id = "patchCoreV1PersistentVolumeStatus", + method = "PATCH", + path = "/api/v1/persistentvolumes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/2/schema"), content = (), required = false),(arg = :force, name = "force", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/parameters/3/schema"), content = (), required = false)), + request = (required = true, media = (("application/apply-patch+cbor", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1apply-patch+cbor/schema"), (), ()),("application/apply-patch+yaml", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1apply-patch+yaml/schema"), (), ()),("application/json-patch+json", IoK8sApimachineryPkgApisMetaV1JSONPatch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1json-patch+json/schema"), (), ()),("application/merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1merge-patch+json/schema"), (), ()),("application/strategic-merge-patch+json", IoK8sApimachineryPkgApisMetaV1Patch, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/requestBody/content/application~1strategic-merge-patch+json/schema"), (), ()))), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/patch/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " patchcorev1persistentvolumestatus(...)\n\npartially update status of the specified PersistentVolume\n\n`PATCH /api/v1/persistentvolumes/{name}/status`" +function patchcorev1persistentvolumestatus(name::String, body::Union{IoK8sApimachineryPkgApisMetaV1JSONPatch,IoK8sApimachineryPkgApisMetaV1Patch}; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, force::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + _openapi_values[:force] = force + return _request(client, _OP_patchcorev1persistentvolumestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_replacecorev1persistentvolumestatus = ( + id = "replaceCoreV1PersistentVolumeStatus", + method = "PUT", + path = "/api/v1/persistentvolumes/{name}/status", + parameters = ((arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/0/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/parameters/1/schema"), content = (), required = false),(arg = :dryrun, name = "dryRun", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/0/schema"), content = (), required = false),(arg = :fieldmanager, name = "fieldManager", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/1/schema"), content = (), required = false),(arg = :fieldvalidation, name = "fieldValidation", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/parameters/2/schema"), content = (), required = false)), + request = (required = true, media = (("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/requestBody/content/application~1json/schema"), (), ()),)), + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "201", media = (("application/cbor", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1cbor/schema"), (), ()),("application/json", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1json/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PersistentVolume, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1persistentvolumes~1{name}~1status/put/responses/201/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " replacecorev1persistentvolumestatus(...)\n\nreplace status of the specified PersistentVolume\n\n`PUT /api/v1/persistentvolumes/{name}/status`" +function replacecorev1persistentvolumestatus(name::String, body::IoK8sApiCoreV1PersistentVolume; pretty::Union{Absent,String} = ABSENT, dryrun::Union{Absent,String} = ABSENT, fieldmanager::Union{Absent,String} = ABSENT, fieldvalidation::Union{Absent,String} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:dryrun] = dryrun + _openapi_values[:fieldmanager] = fieldmanager + _openapi_values[:fieldvalidation] = fieldvalidation + return _request(client, _OP_replacecorev1persistentvolumestatus, _openapi_values; body = body, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1podforallnamespaces = ( + id = "listCoreV1PodForAllNamespaces", + method = "GET", + path = "/api/v1/pods", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1podforallnamespaces(...)\n\nlist or watch objects of kind Pod\n\n`GET /api/v1/pods`" +function listcorev1podforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1podforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1podtemplateforallnamespaces = ( + id = "listCoreV1PodTemplateForAllNamespaces", + method = "GET", + path = "/api/v1/podtemplates", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1PodTemplateList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1podtemplates/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1podtemplateforallnamespaces(...)\n\nlist or watch objects of kind PodTemplate\n\n`GET /api/v1/podtemplates`" +function listcorev1podtemplateforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1podtemplateforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1replicationcontrollerforallnamespaces = ( + id = "listCoreV1ReplicationControllerForAllNamespaces", + method = "GET", + path = "/api/v1/replicationcontrollers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ReplicationControllerList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1replicationcontrollers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1replicationcontrollerforallnamespaces(...)\n\nlist or watch objects of kind ReplicationController\n\n`GET /api/v1/replicationcontrollers`" +function listcorev1replicationcontrollerforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1replicationcontrollerforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1resourcequotaforallnamespaces = ( + id = "listCoreV1ResourceQuotaForAllNamespaces", + method = "GET", + path = "/api/v1/resourcequotas", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ResourceQuotaList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1resourcequotas/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1resourcequotaforallnamespaces(...)\n\nlist or watch objects of kind ResourceQuota\n\n`GET /api/v1/resourcequotas`" +function listcorev1resourcequotaforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1resourcequotaforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1secretforallnamespaces = ( + id = "listCoreV1SecretForAllNamespaces", + method = "GET", + path = "/api/v1/secrets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1SecretList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1secrets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1secretforallnamespaces(...)\n\nlist or watch objects of kind Secret\n\n`GET /api/v1/secrets`" +function listcorev1secretforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1secretforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1serviceaccountforallnamespaces = ( + id = "listCoreV1ServiceAccountForAllNamespaces", + method = "GET", + path = "/api/v1/serviceaccounts", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceAccountList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1serviceaccounts/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1serviceaccountforallnamespaces(...)\n\nlist or watch objects of kind ServiceAccount\n\n`GET /api/v1/serviceaccounts`" +function listcorev1serviceaccountforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1serviceaccountforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_listcorev1serviceforallnamespaces = ( + id = "listCoreV1ServiceForAllNamespaces", + method = "GET", + path = "/api/v1/services", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApiCoreV1ServiceList, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1services/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " listcorev1serviceforallnamespaces(...)\n\nlist or watch objects of kind Service\n\n`GET /api/v1/services`" +function listcorev1serviceforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_listcorev1serviceforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1configmaplistforallnamespaces = ( + id = "watchCoreV1ConfigMapListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/configmaps", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1configmaps/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1configmaplistforallnamespaces(...)\n\nwatch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/configmaps`" +function watchcorev1configmaplistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1configmaplistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1endpointslistforallnamespaces = ( + id = "watchCoreV1EndpointsListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/endpoints", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1endpoints/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1endpointslistforallnamespaces(...)\n\nwatch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/endpoints`" +function watchcorev1endpointslistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1endpointslistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1eventlistforallnamespaces = ( + id = "watchCoreV1EventListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1eventlistforallnamespaces(...)\n\nwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/events`" +function watchcorev1eventlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1eventlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1limitrangelistforallnamespaces = ( + id = "watchCoreV1LimitRangeListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/limitranges", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1limitranges/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1limitrangelistforallnamespaces(...)\n\nwatch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/limitranges`" +function watchcorev1limitrangelistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1limitrangelistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacelist = ( + id = "watchCoreV1NamespaceList", + method = "GET", + path = "/api/v1/watch/namespaces", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacelist(...)\n\nwatch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces`" +function watchcorev1namespacelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedconfigmaplist = ( + id = "watchCoreV1NamespacedConfigMapList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/configmaps", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedconfigmaplist(...)\n\nwatch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/configmaps`" +function watchcorev1namespacedconfigmaplist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedconfigmaplist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedconfigmap = ( + id = "watchCoreV1NamespacedConfigMap", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/configmaps/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1configmaps~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedconfigmap(...)\n\nwatch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/configmaps/{name}`" +function watchcorev1namespacedconfigmap(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedconfigmap, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedendpointslist = ( + id = "watchCoreV1NamespacedEndpointsList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/endpoints", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedendpointslist(...)\n\nwatch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/endpoints`" +function watchcorev1namespacedendpointslist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedendpointslist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedendpoints = ( + id = "watchCoreV1NamespacedEndpoints", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/endpoints/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1endpoints~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedendpoints(...)\n\nwatch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/endpoints/{name}`" +function watchcorev1namespacedendpoints(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedendpoints, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedeventlist = ( + id = "watchCoreV1NamespacedEventList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/events", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedeventlist(...)\n\nwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/events`" +function watchcorev1namespacedeventlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedeventlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedevent = ( + id = "watchCoreV1NamespacedEvent", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/events/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1events~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedevent(...)\n\nwatch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/events/{name}`" +function watchcorev1namespacedevent(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedevent, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedlimitrangelist = ( + id = "watchCoreV1NamespacedLimitRangeList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/limitranges", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedlimitrangelist(...)\n\nwatch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/limitranges`" +function watchcorev1namespacedlimitrangelist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedlimitrangelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedlimitrange = ( + id = "watchCoreV1NamespacedLimitRange", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/limitranges/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1limitranges~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedlimitrange(...)\n\nwatch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/limitranges/{name}`" +function watchcorev1namespacedlimitrange(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedlimitrange, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpersistentvolumeclaimlist = ( + id = "watchCoreV1NamespacedPersistentVolumeClaimList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpersistentvolumeclaimlist(...)\n\nwatch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/persistentvolumeclaims`" +function watchcorev1namespacedpersistentvolumeclaimlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpersistentvolumeclaimlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpersistentvolumeclaim = ( + id = "watchCoreV1NamespacedPersistentVolumeClaim", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1persistentvolumeclaims~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpersistentvolumeclaim(...)\n\nwatch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}`" +function watchcorev1namespacedpersistentvolumeclaim(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpersistentvolumeclaim, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpodlist = ( + id = "watchCoreV1NamespacedPodList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/pods", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpodlist(...)\n\nwatch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/pods`" +function watchcorev1namespacedpodlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpodlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpod = ( + id = "watchCoreV1NamespacedPod", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/pods/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1pods~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpod(...)\n\nwatch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/pods/{name}`" +function watchcorev1namespacedpod(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpod, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpodtemplatelist = ( + id = "watchCoreV1NamespacedPodTemplateList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/podtemplates", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpodtemplatelist(...)\n\nwatch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/podtemplates`" +function watchcorev1namespacedpodtemplatelist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpodtemplatelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedpodtemplate = ( + id = "watchCoreV1NamespacedPodTemplate", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/podtemplates/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1podtemplates~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedpodtemplate(...)\n\nwatch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/podtemplates/{name}`" +function watchcorev1namespacedpodtemplate(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedpodtemplate, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedreplicationcontrollerlist = ( + id = "watchCoreV1NamespacedReplicationControllerList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/replicationcontrollers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedreplicationcontrollerlist(...)\n\nwatch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/replicationcontrollers`" +function watchcorev1namespacedreplicationcontrollerlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedreplicationcontrollerlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedreplicationcontroller = ( + id = "watchCoreV1NamespacedReplicationController", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1replicationcontrollers~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedreplicationcontroller(...)\n\nwatch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}`" +function watchcorev1namespacedreplicationcontroller(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedreplicationcontroller, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedresourcequotalist = ( + id = "watchCoreV1NamespacedResourceQuotaList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/resourcequotas", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedresourcequotalist(...)\n\nwatch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/resourcequotas`" +function watchcorev1namespacedresourcequotalist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedresourcequotalist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedresourcequota = ( + id = "watchCoreV1NamespacedResourceQuota", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1resourcequotas~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedresourcequota(...)\n\nwatch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/resourcequotas/{name}`" +function watchcorev1namespacedresourcequota(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedresourcequota, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedsecretlist = ( + id = "watchCoreV1NamespacedSecretList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/secrets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedsecretlist(...)\n\nwatch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/secrets`" +function watchcorev1namespacedsecretlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedsecretlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedsecret = ( + id = "watchCoreV1NamespacedSecret", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/secrets/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1secrets~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedsecret(...)\n\nwatch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/secrets/{name}`" +function watchcorev1namespacedsecret(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedsecret, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedserviceaccountlist = ( + id = "watchCoreV1NamespacedServiceAccountList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/serviceaccounts", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedserviceaccountlist(...)\n\nwatch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/serviceaccounts`" +function watchcorev1namespacedserviceaccountlist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedserviceaccountlist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedserviceaccount = ( + id = "watchCoreV1NamespacedServiceAccount", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1serviceaccounts~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedserviceaccount(...)\n\nwatch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}`" +function watchcorev1namespacedserviceaccount(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedserviceaccount, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedservicelist = ( + id = "watchCoreV1NamespacedServiceList", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/services", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/4/schema"), content = (), required = false),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/7/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedservicelist(...)\n\nwatch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/namespaces/{namespace}/services`" +function watchcorev1namespacedservicelist(namespace::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedservicelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespacedservice = ( + id = "watchCoreV1NamespacedService", + method = "GET", + path = "/api/v1/watch/namespaces/{namespace}/services/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/5/schema"), content = (), required = true),(arg = :namespace, name = "namespace", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/6/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/7/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/9/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/10/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/11/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/parameters/12/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{namespace}~1services~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespacedservice(...)\n\nwatch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{namespace}/services/{name}`" +function watchcorev1namespacedservice(namespace::String, name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:namespace] = namespace + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespacedservice, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1namespace = ( + id = "watchCoreV1Namespace", + method = "GET", + path = "/api/v1/watch/namespaces/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1namespaces~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1namespace(...)\n\nwatch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/namespaces/{name}`" +function watchcorev1namespace(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1namespace, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1nodelist = ( + id = "watchCoreV1NodeList", + method = "GET", + path = "/api/v1/watch/nodes", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1nodelist(...)\n\nwatch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/nodes`" +function watchcorev1nodelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1nodelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1node = ( + id = "watchCoreV1Node", + method = "GET", + path = "/api/v1/watch/nodes/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1nodes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1node(...)\n\nwatch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/nodes/{name}`" +function watchcorev1node(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1node, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1persistentvolumeclaimlistforallnamespaces = ( + id = "watchCoreV1PersistentVolumeClaimListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/persistentvolumeclaims", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumeclaims/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1persistentvolumeclaimlistforallnamespaces(...)\n\nwatch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/persistentvolumeclaims`" +function watchcorev1persistentvolumeclaimlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1persistentvolumeclaimlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1persistentvolumelist = ( + id = "watchCoreV1PersistentVolumeList", + method = "GET", + path = "/api/v1/watch/persistentvolumes", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1persistentvolumelist(...)\n\nwatch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/persistentvolumes`" +function watchcorev1persistentvolumelist(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1persistentvolumelist, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1persistentvolume = ( + id = "watchCoreV1PersistentVolume", + method = "GET", + path = "/api/v1/watch/persistentvolumes/{name}", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/4/schema"), content = (), required = false),(arg = :name, name = "name", type = String, location = :path, style = :simple, explode = false, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/5/schema"), content = (), required = true),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/6/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/parameters/0/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/8/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/9/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/10/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/parameters/11/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1persistentvolumes~1{name}/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1persistentvolume(...)\n\nwatch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.\n\n`GET /api/v1/watch/persistentvolumes/{name}`" +function watchcorev1persistentvolume(name::String; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:name] = name + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1persistentvolume, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1podlistforallnamespaces = ( + id = "watchCoreV1PodListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/pods", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1pods/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1podlistforallnamespaces(...)\n\nwatch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/pods`" +function watchcorev1podlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1podlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1podtemplatelistforallnamespaces = ( + id = "watchCoreV1PodTemplateListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/podtemplates", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1podtemplates/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1podtemplatelistforallnamespaces(...)\n\nwatch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/podtemplates`" +function watchcorev1podtemplatelistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1podtemplatelistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1replicationcontrollerlistforallnamespaces = ( + id = "watchCoreV1ReplicationControllerListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/replicationcontrollers", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1replicationcontrollers/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1replicationcontrollerlistforallnamespaces(...)\n\nwatch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/replicationcontrollers`" +function watchcorev1replicationcontrollerlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1replicationcontrollerlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1resourcequotalistforallnamespaces = ( + id = "watchCoreV1ResourceQuotaListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/resourcequotas", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1resourcequotas/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1resourcequotalistforallnamespaces(...)\n\nwatch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/resourcequotas`" +function watchcorev1resourcequotalistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1resourcequotalistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1secretlistforallnamespaces = ( + id = "watchCoreV1SecretListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/secrets", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1secrets/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1secretlistforallnamespaces(...)\n\nwatch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/secrets`" +function watchcorev1secretlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1secretlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1serviceaccountlistforallnamespaces = ( + id = "watchCoreV1ServiceAccountListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/serviceaccounts", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1serviceaccounts/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1serviceaccountlistforallnamespaces(...)\n\nwatch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/serviceaccounts`" +function watchcorev1serviceaccountlistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1serviceaccountlistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +const _OP_watchcorev1servicelistforallnamespaces = ( + id = "watchCoreV1ServiceListForAllNamespaces", + method = "GET", + path = "/api/v1/watch/services", + parameters = ((arg = :allowwatchbookmarks, name = "allowWatchBookmarks", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/0/schema"), content = (), required = false),(arg = :continue_, name = "continue", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/1/schema"), content = (), required = false),(arg = :fieldselector, name = "fieldSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/2/schema"), content = (), required = false),(arg = :labelselector, name = "labelSelector", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/3/schema"), content = (), required = false),(arg = :limit, name = "limit", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/4/schema"), content = (), required = false),(arg = :pretty, name = "pretty", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/5/schema"), content = (), required = false),(arg = :resourceversion, name = "resourceVersion", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/6/schema"), content = (), required = false),(arg = :resourceversionmatch, name = "resourceVersionMatch", type = Union{Absent,String}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/7/schema"), content = (), required = false),(arg = :sendinitialevents, name = "sendInitialEvents", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/8/schema"), content = (), required = false),(arg = :timeoutseconds, name = "timeoutSeconds", type = Union{Absent,Int64}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/9/schema"), content = (), required = false),(arg = :watch, name = "watch", type = Union{Absent,Bool}, location = :query, style = :form, explode = true, allow_reserved = false, shape = :scalar, schema = (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/parameters/10/schema"), content = (), required = false)), + request = nothing, + responses = ( + (selector = "200", media = (("application/cbor", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1cbor/schema"), (), ()),("application/cbor-seq", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1cbor-seq/schema"), (), ()),("application/json", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1json/schema"), (), ()),("application/json;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1json;stream=watch/schema"), (), ()),("application/vnd.kubernetes.protobuf", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf/schema"), (), ()),("application/vnd.kubernetes.protobuf;stream=watch", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1vnd.kubernetes.protobuf;stream=watch/schema"), (), ()),("application/yaml", IoK8sApimachineryPkgApisMetaV1WatchEvent, (resource = "https://openapi.invalid/schema/root-a1b7b568883e44149862.json", pointer = "/paths/~1api~1v1~1watch~1services/get/responses/200/content/application~1yaml/schema"), (), ())), headers = ()), + (selector = "401", media = (), headers = ()), + ), + security = (), + servers = ((name = nothing, url = "/", base = "", variables = ()),), +) + +@doc " watchcorev1servicelistforallnamespaces(...)\n\nwatch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.\n\n`GET /api/v1/watch/services`" +function watchcorev1servicelistforallnamespaces(; allowwatchbookmarks::Union{Absent,Bool} = ABSENT, continue_::Union{Absent,String} = ABSENT, fieldselector::Union{Absent,String} = ABSENT, labelselector::Union{Absent,String} = ABSENT, limit::Union{Absent,Int64} = ABSENT, pretty::Union{Absent,String} = ABSENT, resourceversion::Union{Absent,String} = ABSENT, resourceversionmatch::Union{Absent,String} = ABSENT, sendinitialevents::Union{Absent,Bool} = ABSENT, timeoutseconds::Union{Absent,Int64} = ABSENT, watch::Union{Absent,Bool} = ABSENT, client::Runtime.Client = DEFAULT_CLIENT, content_type::Union{Nothing,AbstractString} = nothing, accept::Union{Nothing,AbstractString} = nothing, with_http_info::Bool = false, request_headers = Pair{String,String}[], request_options::NamedTuple = NamedTuple(), stream_to::Union{Nothing,Channel} = nothing) + _openapi_values = Dict{Symbol,Any}() + _openapi_values[:allowwatchbookmarks] = allowwatchbookmarks + _openapi_values[:continue_] = continue_ + _openapi_values[:fieldselector] = fieldselector + _openapi_values[:labelselector] = labelselector + _openapi_values[:limit] = limit + _openapi_values[:pretty] = pretty + _openapi_values[:resourceversion] = resourceversion + _openapi_values[:resourceversionmatch] = resourceversionmatch + _openapi_values[:sendinitialevents] = sendinitialevents + _openapi_values[:timeoutseconds] = timeoutseconds + _openapi_values[:watch] = watch + return _request(client, _OP_watchcorev1servicelistforallnamespaces, _openapi_values; body = ABSENT, content_type, accept, with_http_info, request_headers, request_options, stream_to) +end + +end # module K8sV1 diff --git a/src/ApiImpl/generated/registry.jl b/src/ApiImpl/generated/registry.jl new file mode 100644 index 00000000..e7110be3 --- /dev/null +++ b/src/ApiImpl/generated/registry.jl @@ -0,0 +1,1378 @@ +# Generated by gen/openapi_v1/emit_registry.jl from the patched specs in +# gen/openapi_v1/specs. Do not edit — rerun the pipeline instead +# (fetch_specs.sh -> patch_k8s_spec.jq -> generate.jl -> emit_registry.jl). +# +# Kubernetes v1.35.4, 18 group modules. + +""" +Group-version string (a k8s `apiVersion`) to the generated module serving it. +""" +const GROUP_MODULES = Dict{String,Module}( + "apiextensions.k8s.io/v1" => K8sApiextensionsK8sIoV1, + "apiregistration.k8s.io/v1" => K8sApiregistrationK8sIoV1, + "apps/v1" => K8sAppsV1, + "autoscaling/v1" => K8sAutoscalingV1, + "autoscaling/v2" => K8sAutoscalingV2, + "batch/v1" => K8sBatchV1, + "certificates.k8s.io/v1" => K8sCertificatesK8sIoV1, + "coordination.k8s.io/v1" => K8sCoordinationK8sIoV1, + "discovery.k8s.io/v1" => K8sDiscoveryK8sIoV1, + "events.k8s.io/v1" => K8sEventsK8sIoV1, + "metrics.k8s.io/v1beta1" => K8sMetricsK8sIoV1beta1, + "networking.k8s.io/v1" => K8sNetworkingK8sIoV1, + "node.k8s.io/v1" => K8sNodeK8sIoV1, + "policy/v1" => K8sPolicyV1, + "rbac.authorization.k8s.io/v1" => K8sRbacAuthorizationK8sIoV1, + "scheduling.k8s.io/v1" => K8sSchedulingK8sIoV1, + "storage.k8s.io/v1" => K8sStorageK8sIoV1, + "v1" => K8sV1, +) + +""" +Inverse of [`GROUP_MODULES`]: each group module's own `apiVersion`. +""" +const MODULE_GVS = Dict{Module,String}( + K8sApiextensionsK8sIoV1 => "apiextensions.k8s.io/v1", + K8sApiregistrationK8sIoV1 => "apiregistration.k8s.io/v1", + K8sAppsV1 => "apps/v1", + K8sAutoscalingV1 => "autoscaling/v1", + K8sAutoscalingV2 => "autoscaling/v2", + K8sBatchV1 => "batch/v1", + K8sCertificatesK8sIoV1 => "certificates.k8s.io/v1", + K8sCoordinationK8sIoV1 => "coordination.k8s.io/v1", + K8sDiscoveryK8sIoV1 => "discovery.k8s.io/v1", + K8sEventsK8sIoV1 => "events.k8s.io/v1", + K8sMetricsK8sIoV1beta1 => "metrics.k8s.io/v1beta1", + K8sNetworkingK8sIoV1 => "networking.k8s.io/v1", + K8sNodeK8sIoV1 => "node.k8s.io/v1", + K8sPolicyV1 => "policy/v1", + K8sRbacAuthorizationK8sIoV1 => "rbac.authorization.k8s.io/v1", + K8sSchedulingK8sIoV1 => "scheduling.k8s.io/v1", + K8sStorageK8sIoV1 => "storage.k8s.io/v1", + K8sV1 => "v1", +) + +""" +`(apiVersion, kind)` to the generated model type, from every schema carrying +`x-kubernetes-group-version-kind`. Replaces the old `Typedefs` aliases and +`kuber_type`'s response sniffing, and gives exactly the addressable kinds +rather than every model a `names()` scan would find. +""" +const KIND_TYPES = Dict{Tuple{String,String},Type}( + ("apiextensions.k8s.io/v1", "CustomResourceDefinition") => K8sApiextensionsK8sIoV1.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition, + ("apiextensions.k8s.io/v1", "CustomResourceDefinitionList") => K8sApiextensionsK8sIoV1.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinitionList, + ("apiextensions.k8s.io/v1", "DeleteOptions") => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("apiextensions.k8s.io/v1", "WatchEvent") => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("apiregistration.k8s.io/v1", "APIService") => K8sApiregistrationK8sIoV1.IoK8sKubeAggregatorPkgApisApiregistrationV1APIService, + ("apiregistration.k8s.io/v1", "APIServiceList") => K8sApiregistrationK8sIoV1.IoK8sKubeAggregatorPkgApisApiregistrationV1APIServiceList, + ("apiregistration.k8s.io/v1", "DeleteOptions") => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("apiregistration.k8s.io/v1", "WatchEvent") => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("apps/v1", "ControllerRevision") => K8sAppsV1.IoK8sApiAppsV1ControllerRevision, + ("apps/v1", "ControllerRevisionList") => K8sAppsV1.IoK8sApiAppsV1ControllerRevisionList, + ("apps/v1", "DaemonSet") => K8sAppsV1.IoK8sApiAppsV1DaemonSet, + ("apps/v1", "DaemonSetList") => K8sAppsV1.IoK8sApiAppsV1DaemonSetList, + ("apps/v1", "DeleteOptions") => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("apps/v1", "Deployment") => K8sAppsV1.IoK8sApiAppsV1Deployment, + ("apps/v1", "DeploymentList") => K8sAppsV1.IoK8sApiAppsV1DeploymentList, + ("apps/v1", "ReplicaSet") => K8sAppsV1.IoK8sApiAppsV1ReplicaSet, + ("apps/v1", "ReplicaSetList") => K8sAppsV1.IoK8sApiAppsV1ReplicaSetList, + ("apps/v1", "StatefulSet") => K8sAppsV1.IoK8sApiAppsV1StatefulSet, + ("apps/v1", "StatefulSetList") => K8sAppsV1.IoK8sApiAppsV1StatefulSetList, + ("apps/v1", "WatchEvent") => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("autoscaling/v1", "DeleteOptions") => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("autoscaling/v1", "HorizontalPodAutoscaler") => K8sAutoscalingV1.IoK8sApiAutoscalingV1HorizontalPodAutoscaler, + ("autoscaling/v1", "HorizontalPodAutoscalerList") => K8sAutoscalingV1.IoK8sApiAutoscalingV1HorizontalPodAutoscalerList, + ("autoscaling/v1", "Scale") => K8sV1.IoK8sApiAutoscalingV1Scale, + ("autoscaling/v1", "WatchEvent") => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("autoscaling/v2", "DeleteOptions") => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("autoscaling/v2", "HorizontalPodAutoscaler") => K8sAutoscalingV2.IoK8sApiAutoscalingV2HorizontalPodAutoscaler, + ("autoscaling/v2", "HorizontalPodAutoscalerList") => K8sAutoscalingV2.IoK8sApiAutoscalingV2HorizontalPodAutoscalerList, + ("autoscaling/v2", "WatchEvent") => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("batch/v1", "CronJob") => K8sBatchV1.IoK8sApiBatchV1CronJob, + ("batch/v1", "CronJobList") => K8sBatchV1.IoK8sApiBatchV1CronJobList, + ("batch/v1", "DeleteOptions") => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("batch/v1", "Job") => K8sBatchV1.IoK8sApiBatchV1Job, + ("batch/v1", "JobList") => K8sBatchV1.IoK8sApiBatchV1JobList, + ("batch/v1", "WatchEvent") => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("certificates.k8s.io/v1", "CertificateSigningRequest") => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequest, + ("certificates.k8s.io/v1", "CertificateSigningRequestList") => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequestList, + ("certificates.k8s.io/v1", "DeleteOptions") => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("certificates.k8s.io/v1", "WatchEvent") => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("coordination.k8s.io/v1", "DeleteOptions") => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("coordination.k8s.io/v1", "Lease") => K8sCoordinationK8sIoV1.IoK8sApiCoordinationV1Lease, + ("coordination.k8s.io/v1", "LeaseList") => K8sCoordinationK8sIoV1.IoK8sApiCoordinationV1LeaseList, + ("coordination.k8s.io/v1", "WatchEvent") => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("discovery.k8s.io/v1", "DeleteOptions") => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("discovery.k8s.io/v1", "EndpointSlice") => K8sDiscoveryK8sIoV1.IoK8sApiDiscoveryV1EndpointSlice, + ("discovery.k8s.io/v1", "EndpointSliceList") => K8sDiscoveryK8sIoV1.IoK8sApiDiscoveryV1EndpointSliceList, + ("discovery.k8s.io/v1", "WatchEvent") => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("events.k8s.io/v1", "DeleteOptions") => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("events.k8s.io/v1", "Event") => K8sEventsK8sIoV1.IoK8sApiEventsV1Event, + ("events.k8s.io/v1", "EventList") => K8sEventsK8sIoV1.IoK8sApiEventsV1EventList, + ("events.k8s.io/v1", "WatchEvent") => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("metrics.k8s.io/v1beta1", "NodeMetrics") => K8sMetricsK8sIoV1beta1.IoK8sMetricsPkgApisMetricsV1beta1NodeMetrics, + ("metrics.k8s.io/v1beta1", "NodeMetricsList") => K8sMetricsK8sIoV1beta1.IoK8sMetricsPkgApisMetricsV1beta1NodeMetricsList, + ("metrics.k8s.io/v1beta1", "PodMetrics") => K8sMetricsK8sIoV1beta1.IoK8sMetricsPkgApisMetricsV1beta1PodMetrics, + ("metrics.k8s.io/v1beta1", "PodMetricsList") => K8sMetricsK8sIoV1beta1.IoK8sMetricsPkgApisMetricsV1beta1PodMetricsList, + ("networking.k8s.io/v1", "DeleteOptions") => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("networking.k8s.io/v1", "IPAddress") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IPAddress, + ("networking.k8s.io/v1", "IPAddressList") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IPAddressList, + ("networking.k8s.io/v1", "Ingress") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1Ingress, + ("networking.k8s.io/v1", "IngressClass") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IngressClass, + ("networking.k8s.io/v1", "IngressClassList") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IngressClassList, + ("networking.k8s.io/v1", "IngressList") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IngressList, + ("networking.k8s.io/v1", "NetworkPolicy") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1NetworkPolicy, + ("networking.k8s.io/v1", "NetworkPolicyList") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1NetworkPolicyList, + ("networking.k8s.io/v1", "ServiceCIDR") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1ServiceCIDR, + ("networking.k8s.io/v1", "ServiceCIDRList") => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1ServiceCIDRList, + ("networking.k8s.io/v1", "WatchEvent") => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("node.k8s.io/v1", "DeleteOptions") => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("node.k8s.io/v1", "RuntimeClass") => K8sNodeK8sIoV1.IoK8sApiNodeV1RuntimeClass, + ("node.k8s.io/v1", "RuntimeClassList") => K8sNodeK8sIoV1.IoK8sApiNodeV1RuntimeClassList, + ("node.k8s.io/v1", "WatchEvent") => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("policy/v1", "DeleteOptions") => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("policy/v1", "Eviction") => K8sV1.IoK8sApiPolicyV1Eviction, + ("policy/v1", "PodDisruptionBudget") => K8sPolicyV1.IoK8sApiPolicyV1PodDisruptionBudget, + ("policy/v1", "PodDisruptionBudgetList") => K8sPolicyV1.IoK8sApiPolicyV1PodDisruptionBudgetList, + ("policy/v1", "WatchEvent") => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("rbac.authorization.k8s.io/v1", "ClusterRole") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRole, + ("rbac.authorization.k8s.io/v1", "ClusterRoleBinding") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRoleBinding, + ("rbac.authorization.k8s.io/v1", "ClusterRoleBindingList") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRoleBindingList, + ("rbac.authorization.k8s.io/v1", "ClusterRoleList") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRoleList, + ("rbac.authorization.k8s.io/v1", "DeleteOptions") => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("rbac.authorization.k8s.io/v1", "Role") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1Role, + ("rbac.authorization.k8s.io/v1", "RoleBinding") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1RoleBinding, + ("rbac.authorization.k8s.io/v1", "RoleBindingList") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1RoleBindingList, + ("rbac.authorization.k8s.io/v1", "RoleList") => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1RoleList, + ("rbac.authorization.k8s.io/v1", "WatchEvent") => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("scheduling.k8s.io/v1", "DeleteOptions") => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("scheduling.k8s.io/v1", "PriorityClass") => K8sSchedulingK8sIoV1.IoK8sApiSchedulingV1PriorityClass, + ("scheduling.k8s.io/v1", "PriorityClassList") => K8sSchedulingK8sIoV1.IoK8sApiSchedulingV1PriorityClassList, + ("scheduling.k8s.io/v1", "WatchEvent") => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("storage.k8s.io/v1", "CSIDriver") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIDriver, + ("storage.k8s.io/v1", "CSIDriverList") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIDriverList, + ("storage.k8s.io/v1", "CSINode") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSINode, + ("storage.k8s.io/v1", "CSINodeList") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSINodeList, + ("storage.k8s.io/v1", "CSIStorageCapacity") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIStorageCapacity, + ("storage.k8s.io/v1", "CSIStorageCapacityList") => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIStorageCapacityList, + ("storage.k8s.io/v1", "DeleteOptions") => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("storage.k8s.io/v1", "StorageClass") => K8sStorageK8sIoV1.IoK8sApiStorageV1StorageClass, + ("storage.k8s.io/v1", "StorageClassList") => K8sStorageK8sIoV1.IoK8sApiStorageV1StorageClassList, + ("storage.k8s.io/v1", "VolumeAttachment") => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttachment, + ("storage.k8s.io/v1", "VolumeAttachmentList") => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttachmentList, + ("storage.k8s.io/v1", "VolumeAttributesClass") => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttributesClass, + ("storage.k8s.io/v1", "VolumeAttributesClassList") => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttributesClassList, + ("storage.k8s.io/v1", "WatchEvent") => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, + ("v1", "APIResourceList") => K8sV1.IoK8sApimachineryPkgApisMetaV1APIResourceList, + ("v1", "Binding") => K8sV1.IoK8sApiCoreV1Binding, + ("v1", "ComponentStatus") => K8sV1.IoK8sApiCoreV1ComponentStatus, + ("v1", "ComponentStatusList") => K8sV1.IoK8sApiCoreV1ComponentStatusList, + ("v1", "ConfigMap") => K8sV1.IoK8sApiCoreV1ConfigMap, + ("v1", "ConfigMapList") => K8sV1.IoK8sApiCoreV1ConfigMapList, + ("v1", "DeleteOptions") => K8sV1.IoK8sApimachineryPkgApisMetaV1DeleteOptions, + ("v1", "Endpoints") => K8sV1.IoK8sApiCoreV1Endpoints, + ("v1", "EndpointsList") => K8sV1.IoK8sApiCoreV1EndpointsList, + ("v1", "Event") => K8sV1.IoK8sApiCoreV1Event, + ("v1", "EventList") => K8sV1.IoK8sApiCoreV1EventList, + ("v1", "LimitRange") => K8sV1.IoK8sApiCoreV1LimitRange, + ("v1", "LimitRangeList") => K8sV1.IoK8sApiCoreV1LimitRangeList, + ("v1", "Namespace") => K8sV1.IoK8sApiCoreV1Namespace, + ("v1", "NamespaceList") => K8sV1.IoK8sApiCoreV1NamespaceList, + ("v1", "Node") => K8sV1.IoK8sApiCoreV1Node, + ("v1", "NodeList") => K8sV1.IoK8sApiCoreV1NodeList, + ("v1", "PersistentVolume") => K8sV1.IoK8sApiCoreV1PersistentVolume, + ("v1", "PersistentVolumeClaim") => K8sV1.IoK8sApiCoreV1PersistentVolumeClaim, + ("v1", "PersistentVolumeClaimList") => K8sV1.IoK8sApiCoreV1PersistentVolumeClaimList, + ("v1", "PersistentVolumeList") => K8sV1.IoK8sApiCoreV1PersistentVolumeList, + ("v1", "Pod") => K8sV1.IoK8sApiCoreV1Pod, + ("v1", "PodList") => K8sV1.IoK8sApiCoreV1PodList, + ("v1", "PodTemplate") => K8sV1.IoK8sApiCoreV1PodTemplate, + ("v1", "PodTemplateList") => K8sV1.IoK8sApiCoreV1PodTemplateList, + ("v1", "ReplicationController") => K8sV1.IoK8sApiCoreV1ReplicationController, + ("v1", "ReplicationControllerList") => K8sV1.IoK8sApiCoreV1ReplicationControllerList, + ("v1", "ResourceQuota") => K8sV1.IoK8sApiCoreV1ResourceQuota, + ("v1", "ResourceQuotaList") => K8sV1.IoK8sApiCoreV1ResourceQuotaList, + ("v1", "Secret") => K8sV1.IoK8sApiCoreV1Secret, + ("v1", "SecretList") => K8sV1.IoK8sApiCoreV1SecretList, + ("v1", "Service") => K8sV1.IoK8sApiCoreV1Service, + ("v1", "ServiceAccount") => K8sV1.IoK8sApiCoreV1ServiceAccount, + ("v1", "ServiceAccountList") => K8sV1.IoK8sApiCoreV1ServiceAccountList, + ("v1", "ServiceList") => K8sV1.IoK8sApiCoreV1ServiceList, + ("v1", "Status") => K8sV1.IoK8sApimachineryPkgApisMetaV1Status, + ("v1", "WatchEvent") => K8sV1.IoK8sApimachineryPkgApisMetaV1WatchEvent, +) + +""" +`(module, verb, kind, scope)` to the generated operation function, where +`verb ∈ (:get, :list, :create, :replace, :patch, :delete, :deletecollection)` +and `scope ∈ (:namespaced, :cluster, :allns)`. A build-time table: no `eval`, +no `isdefined` probing, and a missing verb/kind is a clean lookup miss. +""" +const OPS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (K8sApiextensionsK8sIoV1, :create, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.createapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :delete, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.deleteapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :deletecollection, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.deleteapiextensionsv1collectioncustomresourcedefinition, + (K8sApiextensionsK8sIoV1, :get, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.readapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :get, :CustomResourceDefinitionStatus, :cluster) => K8sApiextensionsK8sIoV1.readapiextensionsv1customresourcedefinitionstatus, + (K8sApiextensionsK8sIoV1, :list, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.listapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.patchapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinitionStatus, :cluster) => K8sApiextensionsK8sIoV1.patchapiextensionsv1customresourcedefinitionstatus, + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinition, :cluster) => K8sApiextensionsK8sIoV1.replaceapiextensionsv1customresourcedefinition, + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinitionStatus, :cluster) => K8sApiextensionsK8sIoV1.replaceapiextensionsv1customresourcedefinitionstatus, + (K8sApiregistrationK8sIoV1, :create, :APIService, :cluster) => K8sApiregistrationK8sIoV1.createapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :delete, :APIService, :cluster) => K8sApiregistrationK8sIoV1.deleteapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :deletecollection, :APIService, :cluster) => K8sApiregistrationK8sIoV1.deleteapiregistrationv1collectionapiservice, + (K8sApiregistrationK8sIoV1, :get, :APIService, :cluster) => K8sApiregistrationK8sIoV1.readapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :get, :APIServiceStatus, :cluster) => K8sApiregistrationK8sIoV1.readapiregistrationv1apiservicestatus, + (K8sApiregistrationK8sIoV1, :list, :APIService, :cluster) => K8sApiregistrationK8sIoV1.listapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :patch, :APIService, :cluster) => K8sApiregistrationK8sIoV1.patchapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :patch, :APIServiceStatus, :cluster) => K8sApiregistrationK8sIoV1.patchapiregistrationv1apiservicestatus, + (K8sApiregistrationK8sIoV1, :replace, :APIService, :cluster) => K8sApiregistrationK8sIoV1.replaceapiregistrationv1apiservice, + (K8sApiregistrationK8sIoV1, :replace, :APIServiceStatus, :cluster) => K8sApiregistrationK8sIoV1.replaceapiregistrationv1apiservicestatus, + (K8sAppsV1, :create, :ControllerRevision, :namespaced) => K8sAppsV1.createappsv1namespacedcontrollerrevision, + (K8sAppsV1, :create, :DaemonSet, :namespaced) => K8sAppsV1.createappsv1namespaceddaemonset, + (K8sAppsV1, :create, :Deployment, :namespaced) => K8sAppsV1.createappsv1namespaceddeployment, + (K8sAppsV1, :create, :ReplicaSet, :namespaced) => K8sAppsV1.createappsv1namespacedreplicaset, + (K8sAppsV1, :create, :StatefulSet, :namespaced) => K8sAppsV1.createappsv1namespacedstatefulset, + (K8sAppsV1, :delete, :ControllerRevision, :namespaced) => K8sAppsV1.deleteappsv1namespacedcontrollerrevision, + (K8sAppsV1, :delete, :DaemonSet, :namespaced) => K8sAppsV1.deleteappsv1namespaceddaemonset, + (K8sAppsV1, :delete, :Deployment, :namespaced) => K8sAppsV1.deleteappsv1namespaceddeployment, + (K8sAppsV1, :delete, :ReplicaSet, :namespaced) => K8sAppsV1.deleteappsv1namespacedreplicaset, + (K8sAppsV1, :delete, :StatefulSet, :namespaced) => K8sAppsV1.deleteappsv1namespacedstatefulset, + (K8sAppsV1, :deletecollection, :ControllerRevision, :namespaced) => K8sAppsV1.deleteappsv1collectionnamespacedcontrollerrevision, + (K8sAppsV1, :deletecollection, :DaemonSet, :namespaced) => K8sAppsV1.deleteappsv1collectionnamespaceddaemonset, + (K8sAppsV1, :deletecollection, :Deployment, :namespaced) => K8sAppsV1.deleteappsv1collectionnamespaceddeployment, + (K8sAppsV1, :deletecollection, :ReplicaSet, :namespaced) => K8sAppsV1.deleteappsv1collectionnamespacedreplicaset, + (K8sAppsV1, :deletecollection, :StatefulSet, :namespaced) => K8sAppsV1.deleteappsv1collectionnamespacedstatefulset, + (K8sAppsV1, :get, :ControllerRevision, :namespaced) => K8sAppsV1.readappsv1namespacedcontrollerrevision, + (K8sAppsV1, :get, :DaemonSet, :namespaced) => K8sAppsV1.readappsv1namespaceddaemonset, + (K8sAppsV1, :get, :DaemonSetStatus, :namespaced) => K8sAppsV1.readappsv1namespaceddaemonsetstatus, + (K8sAppsV1, :get, :Deployment, :namespaced) => K8sAppsV1.readappsv1namespaceddeployment, + (K8sAppsV1, :get, :DeploymentScale, :namespaced) => K8sAppsV1.readappsv1namespaceddeploymentscale, + (K8sAppsV1, :get, :DeploymentStatus, :namespaced) => K8sAppsV1.readappsv1namespaceddeploymentstatus, + (K8sAppsV1, :get, :ReplicaSet, :namespaced) => K8sAppsV1.readappsv1namespacedreplicaset, + (K8sAppsV1, :get, :ReplicaSetScale, :namespaced) => K8sAppsV1.readappsv1namespacedreplicasetscale, + (K8sAppsV1, :get, :ReplicaSetStatus, :namespaced) => K8sAppsV1.readappsv1namespacedreplicasetstatus, + (K8sAppsV1, :get, :StatefulSet, :namespaced) => K8sAppsV1.readappsv1namespacedstatefulset, + (K8sAppsV1, :get, :StatefulSetScale, :namespaced) => K8sAppsV1.readappsv1namespacedstatefulsetscale, + (K8sAppsV1, :get, :StatefulSetStatus, :namespaced) => K8sAppsV1.readappsv1namespacedstatefulsetstatus, + (K8sAppsV1, :list, :ControllerRevision, :allns) => K8sAppsV1.listappsv1controllerrevisionforallnamespaces, + (K8sAppsV1, :list, :ControllerRevision, :namespaced) => K8sAppsV1.listappsv1namespacedcontrollerrevision, + (K8sAppsV1, :list, :DaemonSet, :allns) => K8sAppsV1.listappsv1daemonsetforallnamespaces, + (K8sAppsV1, :list, :DaemonSet, :namespaced) => K8sAppsV1.listappsv1namespaceddaemonset, + (K8sAppsV1, :list, :Deployment, :allns) => K8sAppsV1.listappsv1deploymentforallnamespaces, + (K8sAppsV1, :list, :Deployment, :namespaced) => K8sAppsV1.listappsv1namespaceddeployment, + (K8sAppsV1, :list, :ReplicaSet, :allns) => K8sAppsV1.listappsv1replicasetforallnamespaces, + (K8sAppsV1, :list, :ReplicaSet, :namespaced) => K8sAppsV1.listappsv1namespacedreplicaset, + (K8sAppsV1, :list, :StatefulSet, :allns) => K8sAppsV1.listappsv1statefulsetforallnamespaces, + (K8sAppsV1, :list, :StatefulSet, :namespaced) => K8sAppsV1.listappsv1namespacedstatefulset, + (K8sAppsV1, :patch, :ControllerRevision, :namespaced) => K8sAppsV1.patchappsv1namespacedcontrollerrevision, + (K8sAppsV1, :patch, :DaemonSet, :namespaced) => K8sAppsV1.patchappsv1namespaceddaemonset, + (K8sAppsV1, :patch, :DaemonSetStatus, :namespaced) => K8sAppsV1.patchappsv1namespaceddaemonsetstatus, + (K8sAppsV1, :patch, :Deployment, :namespaced) => K8sAppsV1.patchappsv1namespaceddeployment, + (K8sAppsV1, :patch, :DeploymentScale, :namespaced) => K8sAppsV1.patchappsv1namespaceddeploymentscale, + (K8sAppsV1, :patch, :DeploymentStatus, :namespaced) => K8sAppsV1.patchappsv1namespaceddeploymentstatus, + (K8sAppsV1, :patch, :ReplicaSet, :namespaced) => K8sAppsV1.patchappsv1namespacedreplicaset, + (K8sAppsV1, :patch, :ReplicaSetScale, :namespaced) => K8sAppsV1.patchappsv1namespacedreplicasetscale, + (K8sAppsV1, :patch, :ReplicaSetStatus, :namespaced) => K8sAppsV1.patchappsv1namespacedreplicasetstatus, + (K8sAppsV1, :patch, :StatefulSet, :namespaced) => K8sAppsV1.patchappsv1namespacedstatefulset, + (K8sAppsV1, :patch, :StatefulSetScale, :namespaced) => K8sAppsV1.patchappsv1namespacedstatefulsetscale, + (K8sAppsV1, :patch, :StatefulSetStatus, :namespaced) => K8sAppsV1.patchappsv1namespacedstatefulsetstatus, + (K8sAppsV1, :replace, :ControllerRevision, :namespaced) => K8sAppsV1.replaceappsv1namespacedcontrollerrevision, + (K8sAppsV1, :replace, :DaemonSet, :namespaced) => K8sAppsV1.replaceappsv1namespaceddaemonset, + (K8sAppsV1, :replace, :DaemonSetStatus, :namespaced) => K8sAppsV1.replaceappsv1namespaceddaemonsetstatus, + (K8sAppsV1, :replace, :Deployment, :namespaced) => K8sAppsV1.replaceappsv1namespaceddeployment, + (K8sAppsV1, :replace, :DeploymentScale, :namespaced) => K8sAppsV1.replaceappsv1namespaceddeploymentscale, + (K8sAppsV1, :replace, :DeploymentStatus, :namespaced) => K8sAppsV1.replaceappsv1namespaceddeploymentstatus, + (K8sAppsV1, :replace, :ReplicaSet, :namespaced) => K8sAppsV1.replaceappsv1namespacedreplicaset, + (K8sAppsV1, :replace, :ReplicaSetScale, :namespaced) => K8sAppsV1.replaceappsv1namespacedreplicasetscale, + (K8sAppsV1, :replace, :ReplicaSetStatus, :namespaced) => K8sAppsV1.replaceappsv1namespacedreplicasetstatus, + (K8sAppsV1, :replace, :StatefulSet, :namespaced) => K8sAppsV1.replaceappsv1namespacedstatefulset, + (K8sAppsV1, :replace, :StatefulSetScale, :namespaced) => K8sAppsV1.replaceappsv1namespacedstatefulsetscale, + (K8sAppsV1, :replace, :StatefulSetStatus, :namespaced) => K8sAppsV1.replaceappsv1namespacedstatefulsetstatus, + (K8sAutoscalingV1, :create, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.createautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :delete, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.deleteautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :deletecollection, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.deleteautoscalingv1collectionnamespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :get, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.readautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :get, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV1.readautoscalingv1namespacedhorizontalpodautoscalerstatus, + (K8sAutoscalingV1, :list, :HorizontalPodAutoscaler, :allns) => K8sAutoscalingV1.listautoscalingv1horizontalpodautoscalerforallnamespaces, + (K8sAutoscalingV1, :list, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.listautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.patchautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV1.patchautoscalingv1namespacedhorizontalpodautoscalerstatus, + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV1.replaceautoscalingv1namespacedhorizontalpodautoscaler, + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV1.replaceautoscalingv1namespacedhorizontalpodautoscalerstatus, + (K8sAutoscalingV2, :create, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.createautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :delete, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.deleteautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :deletecollection, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.deleteautoscalingv2collectionnamespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :get, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.readautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :get, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV2.readautoscalingv2namespacedhorizontalpodautoscalerstatus, + (K8sAutoscalingV2, :list, :HorizontalPodAutoscaler, :allns) => K8sAutoscalingV2.listautoscalingv2horizontalpodautoscalerforallnamespaces, + (K8sAutoscalingV2, :list, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.listautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.patchautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV2.patchautoscalingv2namespacedhorizontalpodautoscalerstatus, + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscaler, :namespaced) => K8sAutoscalingV2.replaceautoscalingv2namespacedhorizontalpodautoscaler, + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => K8sAutoscalingV2.replaceautoscalingv2namespacedhorizontalpodautoscalerstatus, + (K8sBatchV1, :create, :CronJob, :namespaced) => K8sBatchV1.createbatchv1namespacedcronjob, + (K8sBatchV1, :create, :Job, :namespaced) => K8sBatchV1.createbatchv1namespacedjob, + (K8sBatchV1, :delete, :CronJob, :namespaced) => K8sBatchV1.deletebatchv1namespacedcronjob, + (K8sBatchV1, :delete, :Job, :namespaced) => K8sBatchV1.deletebatchv1namespacedjob, + (K8sBatchV1, :deletecollection, :CronJob, :namespaced) => K8sBatchV1.deletebatchv1collectionnamespacedcronjob, + (K8sBatchV1, :deletecollection, :Job, :namespaced) => K8sBatchV1.deletebatchv1collectionnamespacedjob, + (K8sBatchV1, :get, :CronJob, :namespaced) => K8sBatchV1.readbatchv1namespacedcronjob, + (K8sBatchV1, :get, :CronJobStatus, :namespaced) => K8sBatchV1.readbatchv1namespacedcronjobstatus, + (K8sBatchV1, :get, :Job, :namespaced) => K8sBatchV1.readbatchv1namespacedjob, + (K8sBatchV1, :get, :JobStatus, :namespaced) => K8sBatchV1.readbatchv1namespacedjobstatus, + (K8sBatchV1, :list, :CronJob, :allns) => K8sBatchV1.listbatchv1cronjobforallnamespaces, + (K8sBatchV1, :list, :CronJob, :namespaced) => K8sBatchV1.listbatchv1namespacedcronjob, + (K8sBatchV1, :list, :Job, :allns) => K8sBatchV1.listbatchv1jobforallnamespaces, + (K8sBatchV1, :list, :Job, :namespaced) => K8sBatchV1.listbatchv1namespacedjob, + (K8sBatchV1, :patch, :CronJob, :namespaced) => K8sBatchV1.patchbatchv1namespacedcronjob, + (K8sBatchV1, :patch, :CronJobStatus, :namespaced) => K8sBatchV1.patchbatchv1namespacedcronjobstatus, + (K8sBatchV1, :patch, :Job, :namespaced) => K8sBatchV1.patchbatchv1namespacedjob, + (K8sBatchV1, :patch, :JobStatus, :namespaced) => K8sBatchV1.patchbatchv1namespacedjobstatus, + (K8sBatchV1, :replace, :CronJob, :namespaced) => K8sBatchV1.replacebatchv1namespacedcronjob, + (K8sBatchV1, :replace, :CronJobStatus, :namespaced) => K8sBatchV1.replacebatchv1namespacedcronjobstatus, + (K8sBatchV1, :replace, :Job, :namespaced) => K8sBatchV1.replacebatchv1namespacedjob, + (K8sBatchV1, :replace, :JobStatus, :namespaced) => K8sBatchV1.replacebatchv1namespacedjobstatus, + (K8sCertificatesK8sIoV1, :create, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.createcertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :delete, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.deletecertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :deletecollection, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.deletecertificatesv1collectioncertificatesigningrequest, + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.readcertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequestApproval, :cluster) => K8sCertificatesK8sIoV1.readcertificatesv1certificatesigningrequestapproval, + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequestStatus, :cluster) => K8sCertificatesK8sIoV1.readcertificatesv1certificatesigningrequeststatus, + (K8sCertificatesK8sIoV1, :list, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.listcertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.patchcertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestApproval, :cluster) => K8sCertificatesK8sIoV1.patchcertificatesv1certificatesigningrequestapproval, + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestStatus, :cluster) => K8sCertificatesK8sIoV1.patchcertificatesv1certificatesigningrequeststatus, + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequest, :cluster) => K8sCertificatesK8sIoV1.replacecertificatesv1certificatesigningrequest, + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestApproval, :cluster) => K8sCertificatesK8sIoV1.replacecertificatesv1certificatesigningrequestapproval, + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestStatus, :cluster) => K8sCertificatesK8sIoV1.replacecertificatesv1certificatesigningrequeststatus, + (K8sCoordinationK8sIoV1, :create, :Lease, :namespaced) => K8sCoordinationK8sIoV1.createcoordinationv1namespacedlease, + (K8sCoordinationK8sIoV1, :delete, :Lease, :namespaced) => K8sCoordinationK8sIoV1.deletecoordinationv1namespacedlease, + (K8sCoordinationK8sIoV1, :deletecollection, :Lease, :namespaced) => K8sCoordinationK8sIoV1.deletecoordinationv1collectionnamespacedlease, + (K8sCoordinationK8sIoV1, :get, :Lease, :namespaced) => K8sCoordinationK8sIoV1.readcoordinationv1namespacedlease, + (K8sCoordinationK8sIoV1, :list, :Lease, :allns) => K8sCoordinationK8sIoV1.listcoordinationv1leaseforallnamespaces, + (K8sCoordinationK8sIoV1, :list, :Lease, :namespaced) => K8sCoordinationK8sIoV1.listcoordinationv1namespacedlease, + (K8sCoordinationK8sIoV1, :patch, :Lease, :namespaced) => K8sCoordinationK8sIoV1.patchcoordinationv1namespacedlease, + (K8sCoordinationK8sIoV1, :replace, :Lease, :namespaced) => K8sCoordinationK8sIoV1.replacecoordinationv1namespacedlease, + (K8sDiscoveryK8sIoV1, :create, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.creatediscoveryv1namespacedendpointslice, + (K8sDiscoveryK8sIoV1, :delete, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.deletediscoveryv1namespacedendpointslice, + (K8sDiscoveryK8sIoV1, :deletecollection, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.deletediscoveryv1collectionnamespacedendpointslice, + (K8sDiscoveryK8sIoV1, :get, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.readdiscoveryv1namespacedendpointslice, + (K8sDiscoveryK8sIoV1, :list, :EndpointSlice, :allns) => K8sDiscoveryK8sIoV1.listdiscoveryv1endpointsliceforallnamespaces, + (K8sDiscoveryK8sIoV1, :list, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.listdiscoveryv1namespacedendpointslice, + (K8sDiscoveryK8sIoV1, :patch, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.patchdiscoveryv1namespacedendpointslice, + (K8sDiscoveryK8sIoV1, :replace, :EndpointSlice, :namespaced) => K8sDiscoveryK8sIoV1.replacediscoveryv1namespacedendpointslice, + (K8sEventsK8sIoV1, :create, :Event, :namespaced) => K8sEventsK8sIoV1.createeventsv1namespacedevent, + (K8sEventsK8sIoV1, :delete, :Event, :namespaced) => K8sEventsK8sIoV1.deleteeventsv1namespacedevent, + (K8sEventsK8sIoV1, :deletecollection, :Event, :namespaced) => K8sEventsK8sIoV1.deleteeventsv1collectionnamespacedevent, + (K8sEventsK8sIoV1, :get, :Event, :namespaced) => K8sEventsK8sIoV1.readeventsv1namespacedevent, + (K8sEventsK8sIoV1, :list, :Event, :allns) => K8sEventsK8sIoV1.listeventsv1eventforallnamespaces, + (K8sEventsK8sIoV1, :list, :Event, :namespaced) => K8sEventsK8sIoV1.listeventsv1namespacedevent, + (K8sEventsK8sIoV1, :patch, :Event, :namespaced) => K8sEventsK8sIoV1.patcheventsv1namespacedevent, + (K8sEventsK8sIoV1, :replace, :Event, :namespaced) => K8sEventsK8sIoV1.replaceeventsv1namespacedevent, + (K8sMetricsK8sIoV1beta1, :get, :NodeMetrics, :cluster) => K8sMetricsK8sIoV1beta1.readmetricsv1beta1nodemetrics, + (K8sMetricsK8sIoV1beta1, :get, :PodMetrics, :namespaced) => K8sMetricsK8sIoV1beta1.readmetricsv1beta1namespacedpodmetrics, + (K8sMetricsK8sIoV1beta1, :list, :NodeMetrics, :cluster) => K8sMetricsK8sIoV1beta1.listmetricsv1beta1nodemetrics, + (K8sMetricsK8sIoV1beta1, :list, :PodMetrics, :allns) => K8sMetricsK8sIoV1beta1.listmetricsv1beta1podmetricsforallnamespaces, + (K8sMetricsK8sIoV1beta1, :list, :PodMetrics, :namespaced) => K8sMetricsK8sIoV1beta1.listmetricsv1beta1namespacedpodmetrics, + (K8sNetworkingK8sIoV1, :create, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.createnetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :create, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.createnetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :create, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.createnetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :create, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.createnetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :create, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.createnetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :delete, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :delete, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.deletenetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :delete, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :delete, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.deletenetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :delete, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :deletecollection, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1collectionipaddress, + (K8sNetworkingK8sIoV1, :deletecollection, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.deletenetworkingv1collectionnamespacedingress, + (K8sNetworkingK8sIoV1, :deletecollection, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1collectioningressclass, + (K8sNetworkingK8sIoV1, :deletecollection, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.deletenetworkingv1collectionnamespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :deletecollection, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.deletenetworkingv1collectionservicecidr, + (K8sNetworkingK8sIoV1, :get, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.readnetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :get, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.readnetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :get, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.readnetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :get, :IngressStatus, :namespaced) => K8sNetworkingK8sIoV1.readnetworkingv1namespacedingressstatus, + (K8sNetworkingK8sIoV1, :get, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.readnetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :get, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.readnetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :get, :ServiceCIDRStatus, :cluster) => K8sNetworkingK8sIoV1.readnetworkingv1servicecidrstatus, + (K8sNetworkingK8sIoV1, :list, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.listnetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :list, :Ingress, :allns) => K8sNetworkingK8sIoV1.listnetworkingv1ingressforallnamespaces, + (K8sNetworkingK8sIoV1, :list, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.listnetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :list, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.listnetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :list, :NetworkPolicy, :allns) => K8sNetworkingK8sIoV1.listnetworkingv1networkpolicyforallnamespaces, + (K8sNetworkingK8sIoV1, :list, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.listnetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :list, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.listnetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :patch, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.patchnetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :patch, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.patchnetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :patch, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.patchnetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :patch, :IngressStatus, :namespaced) => K8sNetworkingK8sIoV1.patchnetworkingv1namespacedingressstatus, + (K8sNetworkingK8sIoV1, :patch, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.patchnetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.patchnetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDRStatus, :cluster) => K8sNetworkingK8sIoV1.patchnetworkingv1servicecidrstatus, + (K8sNetworkingK8sIoV1, :replace, :IPAddress, :cluster) => K8sNetworkingK8sIoV1.replacenetworkingv1ipaddress, + (K8sNetworkingK8sIoV1, :replace, :Ingress, :namespaced) => K8sNetworkingK8sIoV1.replacenetworkingv1namespacedingress, + (K8sNetworkingK8sIoV1, :replace, :IngressClass, :cluster) => K8sNetworkingK8sIoV1.replacenetworkingv1ingressclass, + (K8sNetworkingK8sIoV1, :replace, :IngressStatus, :namespaced) => K8sNetworkingK8sIoV1.replacenetworkingv1namespacedingressstatus, + (K8sNetworkingK8sIoV1, :replace, :NetworkPolicy, :namespaced) => K8sNetworkingK8sIoV1.replacenetworkingv1namespacednetworkpolicy, + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDR, :cluster) => K8sNetworkingK8sIoV1.replacenetworkingv1servicecidr, + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDRStatus, :cluster) => K8sNetworkingK8sIoV1.replacenetworkingv1servicecidrstatus, + (K8sNodeK8sIoV1, :create, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.createnodev1runtimeclass, + (K8sNodeK8sIoV1, :delete, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.deletenodev1runtimeclass, + (K8sNodeK8sIoV1, :deletecollection, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.deletenodev1collectionruntimeclass, + (K8sNodeK8sIoV1, :get, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.readnodev1runtimeclass, + (K8sNodeK8sIoV1, :list, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.listnodev1runtimeclass, + (K8sNodeK8sIoV1, :patch, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.patchnodev1runtimeclass, + (K8sNodeK8sIoV1, :replace, :RuntimeClass, :cluster) => K8sNodeK8sIoV1.replacenodev1runtimeclass, + (K8sPolicyV1, :create, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.createpolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :delete, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.deletepolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :deletecollection, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.deletepolicyv1collectionnamespacedpoddisruptionbudget, + (K8sPolicyV1, :get, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.readpolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :get, :PodDisruptionBudgetStatus, :namespaced) => K8sPolicyV1.readpolicyv1namespacedpoddisruptionbudgetstatus, + (K8sPolicyV1, :list, :PodDisruptionBudget, :allns) => K8sPolicyV1.listpolicyv1poddisruptionbudgetforallnamespaces, + (K8sPolicyV1, :list, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.listpolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :patch, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.patchpolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :patch, :PodDisruptionBudgetStatus, :namespaced) => K8sPolicyV1.patchpolicyv1namespacedpoddisruptionbudgetstatus, + (K8sPolicyV1, :replace, :PodDisruptionBudget, :namespaced) => K8sPolicyV1.replacepolicyv1namespacedpoddisruptionbudget, + (K8sPolicyV1, :replace, :PodDisruptionBudgetStatus, :namespaced) => K8sPolicyV1.replacepolicyv1namespacedpoddisruptionbudgetstatus, + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.createrbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.createrbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :create, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.createrbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :create, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.createrbacauthorizationv1namespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :delete, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :delete, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :delete, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :delete, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1namespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1collectionclusterrole, + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1collectionclusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1collectionnamespacedrole, + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.deleterbacauthorizationv1collectionnamespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :get, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.readrbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :get, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.readrbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :get, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.readrbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :get, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.readrbacauthorizationv1namespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :list, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :list, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :list, :Role, :allns) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1roleforallnamespaces, + (K8sRbacAuthorizationK8sIoV1, :list, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :list, :RoleBinding, :allns) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1rolebindingforallnamespaces, + (K8sRbacAuthorizationK8sIoV1, :list, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.listrbacauthorizationv1namespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.patchrbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.patchrbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :patch, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.patchrbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :patch, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.patchrbacauthorizationv1namespacedrolebinding, + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRole, :cluster) => K8sRbacAuthorizationK8sIoV1.replacerbacauthorizationv1clusterrole, + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRoleBinding, :cluster) => K8sRbacAuthorizationK8sIoV1.replacerbacauthorizationv1clusterrolebinding, + (K8sRbacAuthorizationK8sIoV1, :replace, :Role, :namespaced) => K8sRbacAuthorizationK8sIoV1.replacerbacauthorizationv1namespacedrole, + (K8sRbacAuthorizationK8sIoV1, :replace, :RoleBinding, :namespaced) => K8sRbacAuthorizationK8sIoV1.replacerbacauthorizationv1namespacedrolebinding, + (K8sSchedulingK8sIoV1, :create, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.createschedulingv1priorityclass, + (K8sSchedulingK8sIoV1, :delete, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.deleteschedulingv1priorityclass, + (K8sSchedulingK8sIoV1, :deletecollection, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.deleteschedulingv1collectionpriorityclass, + (K8sSchedulingK8sIoV1, :get, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.readschedulingv1priorityclass, + (K8sSchedulingK8sIoV1, :list, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.listschedulingv1priorityclass, + (K8sSchedulingK8sIoV1, :patch, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.patchschedulingv1priorityclass, + (K8sSchedulingK8sIoV1, :replace, :PriorityClass, :cluster) => K8sSchedulingK8sIoV1.replaceschedulingv1priorityclass, + (K8sStorageK8sIoV1, :create, :CSIDriver, :cluster) => K8sStorageK8sIoV1.createstoragev1csidriver, + (K8sStorageK8sIoV1, :create, :CSINode, :cluster) => K8sStorageK8sIoV1.createstoragev1csinode, + (K8sStorageK8sIoV1, :create, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.createstoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :create, :StorageClass, :cluster) => K8sStorageK8sIoV1.createstoragev1storageclass, + (K8sStorageK8sIoV1, :create, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.createstoragev1volumeattachment, + (K8sStorageK8sIoV1, :create, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.createstoragev1volumeattributesclass, + (K8sStorageK8sIoV1, :delete, :CSIDriver, :cluster) => K8sStorageK8sIoV1.deletestoragev1csidriver, + (K8sStorageK8sIoV1, :delete, :CSINode, :cluster) => K8sStorageK8sIoV1.deletestoragev1csinode, + (K8sStorageK8sIoV1, :delete, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.deletestoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :delete, :StorageClass, :cluster) => K8sStorageK8sIoV1.deletestoragev1storageclass, + (K8sStorageK8sIoV1, :delete, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.deletestoragev1volumeattachment, + (K8sStorageK8sIoV1, :delete, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.deletestoragev1volumeattributesclass, + (K8sStorageK8sIoV1, :deletecollection, :CSIDriver, :cluster) => K8sStorageK8sIoV1.deletestoragev1collectioncsidriver, + (K8sStorageK8sIoV1, :deletecollection, :CSINode, :cluster) => K8sStorageK8sIoV1.deletestoragev1collectioncsinode, + (K8sStorageK8sIoV1, :deletecollection, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.deletestoragev1collectionnamespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :deletecollection, :StorageClass, :cluster) => K8sStorageK8sIoV1.deletestoragev1collectionstorageclass, + (K8sStorageK8sIoV1, :deletecollection, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.deletestoragev1collectionvolumeattachment, + (K8sStorageK8sIoV1, :deletecollection, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.deletestoragev1collectionvolumeattributesclass, + (K8sStorageK8sIoV1, :get, :CSIDriver, :cluster) => K8sStorageK8sIoV1.readstoragev1csidriver, + (K8sStorageK8sIoV1, :get, :CSINode, :cluster) => K8sStorageK8sIoV1.readstoragev1csinode, + (K8sStorageK8sIoV1, :get, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.readstoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :get, :StorageClass, :cluster) => K8sStorageK8sIoV1.readstoragev1storageclass, + (K8sStorageK8sIoV1, :get, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.readstoragev1volumeattachment, + (K8sStorageK8sIoV1, :get, :VolumeAttachmentStatus, :cluster) => K8sStorageK8sIoV1.readstoragev1volumeattachmentstatus, + (K8sStorageK8sIoV1, :get, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.readstoragev1volumeattributesclass, + (K8sStorageK8sIoV1, :list, :CSIDriver, :cluster) => K8sStorageK8sIoV1.liststoragev1csidriver, + (K8sStorageK8sIoV1, :list, :CSINode, :cluster) => K8sStorageK8sIoV1.liststoragev1csinode, + (K8sStorageK8sIoV1, :list, :CSIStorageCapacity, :allns) => K8sStorageK8sIoV1.liststoragev1csistoragecapacityforallnamespaces, + (K8sStorageK8sIoV1, :list, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.liststoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :list, :StorageClass, :cluster) => K8sStorageK8sIoV1.liststoragev1storageclass, + (K8sStorageK8sIoV1, :list, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.liststoragev1volumeattachment, + (K8sStorageK8sIoV1, :list, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.liststoragev1volumeattributesclass, + (K8sStorageK8sIoV1, :patch, :CSIDriver, :cluster) => K8sStorageK8sIoV1.patchstoragev1csidriver, + (K8sStorageK8sIoV1, :patch, :CSINode, :cluster) => K8sStorageK8sIoV1.patchstoragev1csinode, + (K8sStorageK8sIoV1, :patch, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.patchstoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :patch, :StorageClass, :cluster) => K8sStorageK8sIoV1.patchstoragev1storageclass, + (K8sStorageK8sIoV1, :patch, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.patchstoragev1volumeattachment, + (K8sStorageK8sIoV1, :patch, :VolumeAttachmentStatus, :cluster) => K8sStorageK8sIoV1.patchstoragev1volumeattachmentstatus, + (K8sStorageK8sIoV1, :patch, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.patchstoragev1volumeattributesclass, + (K8sStorageK8sIoV1, :replace, :CSIDriver, :cluster) => K8sStorageK8sIoV1.replacestoragev1csidriver, + (K8sStorageK8sIoV1, :replace, :CSINode, :cluster) => K8sStorageK8sIoV1.replacestoragev1csinode, + (K8sStorageK8sIoV1, :replace, :CSIStorageCapacity, :namespaced) => K8sStorageK8sIoV1.replacestoragev1namespacedcsistoragecapacity, + (K8sStorageK8sIoV1, :replace, :StorageClass, :cluster) => K8sStorageK8sIoV1.replacestoragev1storageclass, + (K8sStorageK8sIoV1, :replace, :VolumeAttachment, :cluster) => K8sStorageK8sIoV1.replacestoragev1volumeattachment, + (K8sStorageK8sIoV1, :replace, :VolumeAttachmentStatus, :cluster) => K8sStorageK8sIoV1.replacestoragev1volumeattachmentstatus, + (K8sStorageK8sIoV1, :replace, :VolumeAttributesClass, :cluster) => K8sStorageK8sIoV1.replacestoragev1volumeattributesclass, + (K8sV1, :create, :Binding, :namespaced) => K8sV1.createcorev1namespacedbinding, + (K8sV1, :create, :ConfigMap, :namespaced) => K8sV1.createcorev1namespacedconfigmap, + (K8sV1, :create, :Endpoints, :namespaced) => K8sV1.createcorev1namespacedendpoints, + (K8sV1, :create, :Event, :namespaced) => K8sV1.createcorev1namespacedevent, + (K8sV1, :create, :LimitRange, :namespaced) => K8sV1.createcorev1namespacedlimitrange, + (K8sV1, :create, :Namespace, :cluster) => K8sV1.createcorev1namespace, + (K8sV1, :create, :Node, :cluster) => K8sV1.createcorev1node, + (K8sV1, :create, :PersistentVolume, :cluster) => K8sV1.createcorev1persistentvolume, + (K8sV1, :create, :PersistentVolumeClaim, :namespaced) => K8sV1.createcorev1namespacedpersistentvolumeclaim, + (K8sV1, :create, :Pod, :namespaced) => K8sV1.createcorev1namespacedpod, + (K8sV1, :create, :PodBinding, :namespaced) => K8sV1.createcorev1namespacedpodbinding, + (K8sV1, :create, :PodEviction, :namespaced) => K8sV1.createcorev1namespacedpodeviction, + (K8sV1, :create, :PodTemplate, :namespaced) => K8sV1.createcorev1namespacedpodtemplate, + (K8sV1, :create, :ReplicationController, :namespaced) => K8sV1.createcorev1namespacedreplicationcontroller, + (K8sV1, :create, :ResourceQuota, :namespaced) => K8sV1.createcorev1namespacedresourcequota, + (K8sV1, :create, :Secret, :namespaced) => K8sV1.createcorev1namespacedsecret, + (K8sV1, :create, :Service, :namespaced) => K8sV1.createcorev1namespacedservice, + (K8sV1, :create, :ServiceAccount, :namespaced) => K8sV1.createcorev1namespacedserviceaccount, + (K8sV1, :create, :ServiceAccountToken, :namespaced) => K8sV1.createcorev1namespacedserviceaccounttoken, + (K8sV1, :delete, :ConfigMap, :namespaced) => K8sV1.deletecorev1namespacedconfigmap, + (K8sV1, :delete, :Endpoints, :namespaced) => K8sV1.deletecorev1namespacedendpoints, + (K8sV1, :delete, :Event, :namespaced) => K8sV1.deletecorev1namespacedevent, + (K8sV1, :delete, :LimitRange, :namespaced) => K8sV1.deletecorev1namespacedlimitrange, + (K8sV1, :delete, :Namespace, :cluster) => K8sV1.deletecorev1namespace, + (K8sV1, :delete, :Node, :cluster) => K8sV1.deletecorev1node, + (K8sV1, :delete, :PersistentVolume, :cluster) => K8sV1.deletecorev1persistentvolume, + (K8sV1, :delete, :PersistentVolumeClaim, :namespaced) => K8sV1.deletecorev1namespacedpersistentvolumeclaim, + (K8sV1, :delete, :Pod, :namespaced) => K8sV1.deletecorev1namespacedpod, + (K8sV1, :delete, :PodTemplate, :namespaced) => K8sV1.deletecorev1namespacedpodtemplate, + (K8sV1, :delete, :ReplicationController, :namespaced) => K8sV1.deletecorev1namespacedreplicationcontroller, + (K8sV1, :delete, :ResourceQuota, :namespaced) => K8sV1.deletecorev1namespacedresourcequota, + (K8sV1, :delete, :Secret, :namespaced) => K8sV1.deletecorev1namespacedsecret, + (K8sV1, :delete, :Service, :namespaced) => K8sV1.deletecorev1namespacedservice, + (K8sV1, :delete, :ServiceAccount, :namespaced) => K8sV1.deletecorev1namespacedserviceaccount, + (K8sV1, :deletecollection, :ConfigMap, :namespaced) => K8sV1.deletecorev1collectionnamespacedconfigmap, + (K8sV1, :deletecollection, :Endpoints, :namespaced) => K8sV1.deletecorev1collectionnamespacedendpoints, + (K8sV1, :deletecollection, :Event, :namespaced) => K8sV1.deletecorev1collectionnamespacedevent, + (K8sV1, :deletecollection, :LimitRange, :namespaced) => K8sV1.deletecorev1collectionnamespacedlimitrange, + (K8sV1, :deletecollection, :Node, :cluster) => K8sV1.deletecorev1collectionnode, + (K8sV1, :deletecollection, :PersistentVolume, :cluster) => K8sV1.deletecorev1collectionpersistentvolume, + (K8sV1, :deletecollection, :PersistentVolumeClaim, :namespaced) => K8sV1.deletecorev1collectionnamespacedpersistentvolumeclaim, + (K8sV1, :deletecollection, :Pod, :namespaced) => K8sV1.deletecorev1collectionnamespacedpod, + (K8sV1, :deletecollection, :PodTemplate, :namespaced) => K8sV1.deletecorev1collectionnamespacedpodtemplate, + (K8sV1, :deletecollection, :ReplicationController, :namespaced) => K8sV1.deletecorev1collectionnamespacedreplicationcontroller, + (K8sV1, :deletecollection, :ResourceQuota, :namespaced) => K8sV1.deletecorev1collectionnamespacedresourcequota, + (K8sV1, :deletecollection, :Secret, :namespaced) => K8sV1.deletecorev1collectionnamespacedsecret, + (K8sV1, :deletecollection, :Service, :namespaced) => K8sV1.deletecorev1collectionnamespacedservice, + (K8sV1, :deletecollection, :ServiceAccount, :namespaced) => K8sV1.deletecorev1collectionnamespacedserviceaccount, + (K8sV1, :get, :ComponentStatus, :cluster) => K8sV1.readcorev1componentstatus, + (K8sV1, :get, :ConfigMap, :namespaced) => K8sV1.readcorev1namespacedconfigmap, + (K8sV1, :get, :Endpoints, :namespaced) => K8sV1.readcorev1namespacedendpoints, + (K8sV1, :get, :Event, :namespaced) => K8sV1.readcorev1namespacedevent, + (K8sV1, :get, :LimitRange, :namespaced) => K8sV1.readcorev1namespacedlimitrange, + (K8sV1, :get, :Namespace, :cluster) => K8sV1.readcorev1namespace, + (K8sV1, :get, :NamespaceStatus, :cluster) => K8sV1.readcorev1namespacestatus, + (K8sV1, :get, :Node, :cluster) => K8sV1.readcorev1node, + (K8sV1, :get, :NodeStatus, :cluster) => K8sV1.readcorev1nodestatus, + (K8sV1, :get, :PersistentVolume, :cluster) => K8sV1.readcorev1persistentvolume, + (K8sV1, :get, :PersistentVolumeClaim, :namespaced) => K8sV1.readcorev1namespacedpersistentvolumeclaim, + (K8sV1, :get, :PersistentVolumeClaimStatus, :namespaced) => K8sV1.readcorev1namespacedpersistentvolumeclaimstatus, + (K8sV1, :get, :PersistentVolumeStatus, :cluster) => K8sV1.readcorev1persistentvolumestatus, + (K8sV1, :get, :Pod, :namespaced) => K8sV1.readcorev1namespacedpod, + (K8sV1, :get, :PodEphemeralcontainers, :namespaced) => K8sV1.readcorev1namespacedpodephemeralcontainers, + (K8sV1, :get, :PodLog, :namespaced) => K8sV1.readcorev1namespacedpodlog, + (K8sV1, :get, :PodResize, :namespaced) => K8sV1.readcorev1namespacedpodresize, + (K8sV1, :get, :PodStatus, :namespaced) => K8sV1.readcorev1namespacedpodstatus, + (K8sV1, :get, :PodTemplate, :namespaced) => K8sV1.readcorev1namespacedpodtemplate, + (K8sV1, :get, :ReplicationController, :namespaced) => K8sV1.readcorev1namespacedreplicationcontroller, + (K8sV1, :get, :ReplicationControllerScale, :namespaced) => K8sV1.readcorev1namespacedreplicationcontrollerscale, + (K8sV1, :get, :ReplicationControllerStatus, :namespaced) => K8sV1.readcorev1namespacedreplicationcontrollerstatus, + (K8sV1, :get, :ResourceQuota, :namespaced) => K8sV1.readcorev1namespacedresourcequota, + (K8sV1, :get, :ResourceQuotaStatus, :namespaced) => K8sV1.readcorev1namespacedresourcequotastatus, + (K8sV1, :get, :Secret, :namespaced) => K8sV1.readcorev1namespacedsecret, + (K8sV1, :get, :Service, :namespaced) => K8sV1.readcorev1namespacedservice, + (K8sV1, :get, :ServiceAccount, :namespaced) => K8sV1.readcorev1namespacedserviceaccount, + (K8sV1, :get, :ServiceStatus, :namespaced) => K8sV1.readcorev1namespacedservicestatus, + (K8sV1, :list, :ComponentStatus, :cluster) => K8sV1.listcorev1componentstatus, + (K8sV1, :list, :ConfigMap, :allns) => K8sV1.listcorev1configmapforallnamespaces, + (K8sV1, :list, :ConfigMap, :namespaced) => K8sV1.listcorev1namespacedconfigmap, + (K8sV1, :list, :Endpoints, :allns) => K8sV1.listcorev1endpointsforallnamespaces, + (K8sV1, :list, :Endpoints, :namespaced) => K8sV1.listcorev1namespacedendpoints, + (K8sV1, :list, :Event, :allns) => K8sV1.listcorev1eventforallnamespaces, + (K8sV1, :list, :Event, :namespaced) => K8sV1.listcorev1namespacedevent, + (K8sV1, :list, :LimitRange, :allns) => K8sV1.listcorev1limitrangeforallnamespaces, + (K8sV1, :list, :LimitRange, :namespaced) => K8sV1.listcorev1namespacedlimitrange, + (K8sV1, :list, :Namespace, :cluster) => K8sV1.listcorev1namespace, + (K8sV1, :list, :Node, :cluster) => K8sV1.listcorev1node, + (K8sV1, :list, :PersistentVolume, :cluster) => K8sV1.listcorev1persistentvolume, + (K8sV1, :list, :PersistentVolumeClaim, :allns) => K8sV1.listcorev1persistentvolumeclaimforallnamespaces, + (K8sV1, :list, :PersistentVolumeClaim, :namespaced) => K8sV1.listcorev1namespacedpersistentvolumeclaim, + (K8sV1, :list, :Pod, :allns) => K8sV1.listcorev1podforallnamespaces, + (K8sV1, :list, :Pod, :namespaced) => K8sV1.listcorev1namespacedpod, + (K8sV1, :list, :PodTemplate, :allns) => K8sV1.listcorev1podtemplateforallnamespaces, + (K8sV1, :list, :PodTemplate, :namespaced) => K8sV1.listcorev1namespacedpodtemplate, + (K8sV1, :list, :ReplicationController, :allns) => K8sV1.listcorev1replicationcontrollerforallnamespaces, + (K8sV1, :list, :ReplicationController, :namespaced) => K8sV1.listcorev1namespacedreplicationcontroller, + (K8sV1, :list, :ResourceQuota, :allns) => K8sV1.listcorev1resourcequotaforallnamespaces, + (K8sV1, :list, :ResourceQuota, :namespaced) => K8sV1.listcorev1namespacedresourcequota, + (K8sV1, :list, :Secret, :allns) => K8sV1.listcorev1secretforallnamespaces, + (K8sV1, :list, :Secret, :namespaced) => K8sV1.listcorev1namespacedsecret, + (K8sV1, :list, :Service, :allns) => K8sV1.listcorev1serviceforallnamespaces, + (K8sV1, :list, :Service, :namespaced) => K8sV1.listcorev1namespacedservice, + (K8sV1, :list, :ServiceAccount, :allns) => K8sV1.listcorev1serviceaccountforallnamespaces, + (K8sV1, :list, :ServiceAccount, :namespaced) => K8sV1.listcorev1namespacedserviceaccount, + (K8sV1, :patch, :ConfigMap, :namespaced) => K8sV1.patchcorev1namespacedconfigmap, + (K8sV1, :patch, :Endpoints, :namespaced) => K8sV1.patchcorev1namespacedendpoints, + (K8sV1, :patch, :Event, :namespaced) => K8sV1.patchcorev1namespacedevent, + (K8sV1, :patch, :LimitRange, :namespaced) => K8sV1.patchcorev1namespacedlimitrange, + (K8sV1, :patch, :Namespace, :cluster) => K8sV1.patchcorev1namespace, + (K8sV1, :patch, :NamespaceStatus, :cluster) => K8sV1.patchcorev1namespacestatus, + (K8sV1, :patch, :Node, :cluster) => K8sV1.patchcorev1node, + (K8sV1, :patch, :NodeStatus, :cluster) => K8sV1.patchcorev1nodestatus, + (K8sV1, :patch, :PersistentVolume, :cluster) => K8sV1.patchcorev1persistentvolume, + (K8sV1, :patch, :PersistentVolumeClaim, :namespaced) => K8sV1.patchcorev1namespacedpersistentvolumeclaim, + (K8sV1, :patch, :PersistentVolumeClaimStatus, :namespaced) => K8sV1.patchcorev1namespacedpersistentvolumeclaimstatus, + (K8sV1, :patch, :PersistentVolumeStatus, :cluster) => K8sV1.patchcorev1persistentvolumestatus, + (K8sV1, :patch, :Pod, :namespaced) => K8sV1.patchcorev1namespacedpod, + (K8sV1, :patch, :PodEphemeralcontainers, :namespaced) => K8sV1.patchcorev1namespacedpodephemeralcontainers, + (K8sV1, :patch, :PodResize, :namespaced) => K8sV1.patchcorev1namespacedpodresize, + (K8sV1, :patch, :PodStatus, :namespaced) => K8sV1.patchcorev1namespacedpodstatus, + (K8sV1, :patch, :PodTemplate, :namespaced) => K8sV1.patchcorev1namespacedpodtemplate, + (K8sV1, :patch, :ReplicationController, :namespaced) => K8sV1.patchcorev1namespacedreplicationcontroller, + (K8sV1, :patch, :ReplicationControllerScale, :namespaced) => K8sV1.patchcorev1namespacedreplicationcontrollerscale, + (K8sV1, :patch, :ReplicationControllerStatus, :namespaced) => K8sV1.patchcorev1namespacedreplicationcontrollerstatus, + (K8sV1, :patch, :ResourceQuota, :namespaced) => K8sV1.patchcorev1namespacedresourcequota, + (K8sV1, :patch, :ResourceQuotaStatus, :namespaced) => K8sV1.patchcorev1namespacedresourcequotastatus, + (K8sV1, :patch, :Secret, :namespaced) => K8sV1.patchcorev1namespacedsecret, + (K8sV1, :patch, :Service, :namespaced) => K8sV1.patchcorev1namespacedservice, + (K8sV1, :patch, :ServiceAccount, :namespaced) => K8sV1.patchcorev1namespacedserviceaccount, + (K8sV1, :patch, :ServiceStatus, :namespaced) => K8sV1.patchcorev1namespacedservicestatus, + (K8sV1, :replace, :ConfigMap, :namespaced) => K8sV1.replacecorev1namespacedconfigmap, + (K8sV1, :replace, :Endpoints, :namespaced) => K8sV1.replacecorev1namespacedendpoints, + (K8sV1, :replace, :Event, :namespaced) => K8sV1.replacecorev1namespacedevent, + (K8sV1, :replace, :LimitRange, :namespaced) => K8sV1.replacecorev1namespacedlimitrange, + (K8sV1, :replace, :Namespace, :cluster) => K8sV1.replacecorev1namespace, + (K8sV1, :replace, :NamespaceFinalize, :cluster) => K8sV1.replacecorev1namespacefinalize, + (K8sV1, :replace, :NamespaceStatus, :cluster) => K8sV1.replacecorev1namespacestatus, + (K8sV1, :replace, :Node, :cluster) => K8sV1.replacecorev1node, + (K8sV1, :replace, :NodeStatus, :cluster) => K8sV1.replacecorev1nodestatus, + (K8sV1, :replace, :PersistentVolume, :cluster) => K8sV1.replacecorev1persistentvolume, + (K8sV1, :replace, :PersistentVolumeClaim, :namespaced) => K8sV1.replacecorev1namespacedpersistentvolumeclaim, + (K8sV1, :replace, :PersistentVolumeClaimStatus, :namespaced) => K8sV1.replacecorev1namespacedpersistentvolumeclaimstatus, + (K8sV1, :replace, :PersistentVolumeStatus, :cluster) => K8sV1.replacecorev1persistentvolumestatus, + (K8sV1, :replace, :Pod, :namespaced) => K8sV1.replacecorev1namespacedpod, + (K8sV1, :replace, :PodEphemeralcontainers, :namespaced) => K8sV1.replacecorev1namespacedpodephemeralcontainers, + (K8sV1, :replace, :PodResize, :namespaced) => K8sV1.replacecorev1namespacedpodresize, + (K8sV1, :replace, :PodStatus, :namespaced) => K8sV1.replacecorev1namespacedpodstatus, + (K8sV1, :replace, :PodTemplate, :namespaced) => K8sV1.replacecorev1namespacedpodtemplate, + (K8sV1, :replace, :ReplicationController, :namespaced) => K8sV1.replacecorev1namespacedreplicationcontroller, + (K8sV1, :replace, :ReplicationControllerScale, :namespaced) => K8sV1.replacecorev1namespacedreplicationcontrollerscale, + (K8sV1, :replace, :ReplicationControllerStatus, :namespaced) => K8sV1.replacecorev1namespacedreplicationcontrollerstatus, + (K8sV1, :replace, :ResourceQuota, :namespaced) => K8sV1.replacecorev1namespacedresourcequota, + (K8sV1, :replace, :ResourceQuotaStatus, :namespaced) => K8sV1.replacecorev1namespacedresourcequotastatus, + (K8sV1, :replace, :Secret, :namespaced) => K8sV1.replacecorev1namespacedsecret, + (K8sV1, :replace, :Service, :namespaced) => K8sV1.replacecorev1namespacedservice, + (K8sV1, :replace, :ServiceAccount, :namespaced) => K8sV1.replacecorev1namespacedserviceaccount, + (K8sV1, :replace, :ServiceStatus, :namespaced) => K8sV1.replacecorev1namespacedservicestatus, +) + +""" +Positional argument names for each [`OPS`] entry, in call order: path +parameters in path order (namespace before name), then `:body`. +""" +const OP_PARAMS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (K8sApiextensionsK8sIoV1, :create, :CustomResourceDefinition, :cluster) => [:body], + (K8sApiextensionsK8sIoV1, :delete, :CustomResourceDefinition, :cluster) => [:name], + (K8sApiextensionsK8sIoV1, :deletecollection, :CustomResourceDefinition, :cluster) => Symbol[], + (K8sApiextensionsK8sIoV1, :get, :CustomResourceDefinition, :cluster) => [:name], + (K8sApiextensionsK8sIoV1, :get, :CustomResourceDefinitionStatus, :cluster) => [:name], + (K8sApiextensionsK8sIoV1, :list, :CustomResourceDefinition, :cluster) => Symbol[], + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinition, :cluster) => [:name, :body], + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinitionStatus, :cluster) => [:name, :body], + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinition, :cluster) => [:name, :body], + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinitionStatus, :cluster) => [:name, :body], + (K8sApiregistrationK8sIoV1, :create, :APIService, :cluster) => [:body], + (K8sApiregistrationK8sIoV1, :delete, :APIService, :cluster) => [:name], + (K8sApiregistrationK8sIoV1, :deletecollection, :APIService, :cluster) => Symbol[], + (K8sApiregistrationK8sIoV1, :get, :APIService, :cluster) => [:name], + (K8sApiregistrationK8sIoV1, :get, :APIServiceStatus, :cluster) => [:name], + (K8sApiregistrationK8sIoV1, :list, :APIService, :cluster) => Symbol[], + (K8sApiregistrationK8sIoV1, :patch, :APIService, :cluster) => [:name, :body], + (K8sApiregistrationK8sIoV1, :patch, :APIServiceStatus, :cluster) => [:name, :body], + (K8sApiregistrationK8sIoV1, :replace, :APIService, :cluster) => [:name, :body], + (K8sApiregistrationK8sIoV1, :replace, :APIServiceStatus, :cluster) => [:name, :body], + (K8sAppsV1, :create, :ControllerRevision, :namespaced) => [:namespace, :body], + (K8sAppsV1, :create, :DaemonSet, :namespaced) => [:namespace, :body], + (K8sAppsV1, :create, :Deployment, :namespaced) => [:namespace, :body], + (K8sAppsV1, :create, :ReplicaSet, :namespaced) => [:namespace, :body], + (K8sAppsV1, :create, :StatefulSet, :namespaced) => [:namespace, :body], + (K8sAppsV1, :delete, :ControllerRevision, :namespaced) => [:namespace, :name], + (K8sAppsV1, :delete, :DaemonSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :delete, :Deployment, :namespaced) => [:namespace, :name], + (K8sAppsV1, :delete, :ReplicaSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :delete, :StatefulSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :deletecollection, :ControllerRevision, :namespaced) => [:namespace], + (K8sAppsV1, :deletecollection, :DaemonSet, :namespaced) => [:namespace], + (K8sAppsV1, :deletecollection, :Deployment, :namespaced) => [:namespace], + (K8sAppsV1, :deletecollection, :ReplicaSet, :namespaced) => [:namespace], + (K8sAppsV1, :deletecollection, :StatefulSet, :namespaced) => [:namespace], + (K8sAppsV1, :get, :ControllerRevision, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :DaemonSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :DaemonSetStatus, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :Deployment, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :DeploymentScale, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :DeploymentStatus, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :ReplicaSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :ReplicaSetScale, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :ReplicaSetStatus, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :StatefulSet, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :StatefulSetScale, :namespaced) => [:namespace, :name], + (K8sAppsV1, :get, :StatefulSetStatus, :namespaced) => [:namespace, :name], + (K8sAppsV1, :list, :ControllerRevision, :allns) => Symbol[], + (K8sAppsV1, :list, :ControllerRevision, :namespaced) => [:namespace], + (K8sAppsV1, :list, :DaemonSet, :allns) => Symbol[], + (K8sAppsV1, :list, :DaemonSet, :namespaced) => [:namespace], + (K8sAppsV1, :list, :Deployment, :allns) => Symbol[], + (K8sAppsV1, :list, :Deployment, :namespaced) => [:namespace], + (K8sAppsV1, :list, :ReplicaSet, :allns) => Symbol[], + (K8sAppsV1, :list, :ReplicaSet, :namespaced) => [:namespace], + (K8sAppsV1, :list, :StatefulSet, :allns) => Symbol[], + (K8sAppsV1, :list, :StatefulSet, :namespaced) => [:namespace], + (K8sAppsV1, :patch, :ControllerRevision, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :DaemonSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :DaemonSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :Deployment, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :DeploymentScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :DeploymentStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :ReplicaSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :ReplicaSetScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :ReplicaSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :StatefulSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :StatefulSetScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :patch, :StatefulSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :ControllerRevision, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :DaemonSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :DaemonSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :Deployment, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :DeploymentScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :DeploymentStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :ReplicaSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :ReplicaSetScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :ReplicaSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :StatefulSet, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :StatefulSetScale, :namespaced) => [:namespace, :name, :body], + (K8sAppsV1, :replace, :StatefulSetStatus, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV1, :create, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :body], + (K8sAutoscalingV1, :delete, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name], + (K8sAutoscalingV1, :deletecollection, :HorizontalPodAutoscaler, :namespaced) => [:namespace], + (K8sAutoscalingV1, :get, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name], + (K8sAutoscalingV1, :get, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name], + (K8sAutoscalingV1, :list, :HorizontalPodAutoscaler, :allns) => Symbol[], + (K8sAutoscalingV1, :list, :HorizontalPodAutoscaler, :namespaced) => [:namespace], + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV2, :create, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :body], + (K8sAutoscalingV2, :delete, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name], + (K8sAutoscalingV2, :deletecollection, :HorizontalPodAutoscaler, :namespaced) => [:namespace], + (K8sAutoscalingV2, :get, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name], + (K8sAutoscalingV2, :get, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name], + (K8sAutoscalingV2, :list, :HorizontalPodAutoscaler, :allns) => Symbol[], + (K8sAutoscalingV2, :list, :HorizontalPodAutoscaler, :namespaced) => [:namespace], + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscaler, :namespaced) => [:namespace, :name, :body], + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :create, :CronJob, :namespaced) => [:namespace, :body], + (K8sBatchV1, :create, :Job, :namespaced) => [:namespace, :body], + (K8sBatchV1, :delete, :CronJob, :namespaced) => [:namespace, :name], + (K8sBatchV1, :delete, :Job, :namespaced) => [:namespace, :name], + (K8sBatchV1, :deletecollection, :CronJob, :namespaced) => [:namespace], + (K8sBatchV1, :deletecollection, :Job, :namespaced) => [:namespace], + (K8sBatchV1, :get, :CronJob, :namespaced) => [:namespace, :name], + (K8sBatchV1, :get, :CronJobStatus, :namespaced) => [:namespace, :name], + (K8sBatchV1, :get, :Job, :namespaced) => [:namespace, :name], + (K8sBatchV1, :get, :JobStatus, :namespaced) => [:namespace, :name], + (K8sBatchV1, :list, :CronJob, :allns) => Symbol[], + (K8sBatchV1, :list, :CronJob, :namespaced) => [:namespace], + (K8sBatchV1, :list, :Job, :allns) => Symbol[], + (K8sBatchV1, :list, :Job, :namespaced) => [:namespace], + (K8sBatchV1, :patch, :CronJob, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :patch, :CronJobStatus, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :patch, :Job, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :patch, :JobStatus, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :replace, :CronJob, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :replace, :CronJobStatus, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :replace, :Job, :namespaced) => [:namespace, :name, :body], + (K8sBatchV1, :replace, :JobStatus, :namespaced) => [:namespace, :name, :body], + (K8sCertificatesK8sIoV1, :create, :CertificateSigningRequest, :cluster) => [:body], + (K8sCertificatesK8sIoV1, :delete, :CertificateSigningRequest, :cluster) => [:name], + (K8sCertificatesK8sIoV1, :deletecollection, :CertificateSigningRequest, :cluster) => Symbol[], + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequest, :cluster) => [:name], + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequestApproval, :cluster) => [:name], + (K8sCertificatesK8sIoV1, :get, :CertificateSigningRequestStatus, :cluster) => [:name], + (K8sCertificatesK8sIoV1, :list, :CertificateSigningRequest, :cluster) => Symbol[], + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequest, :cluster) => [:name, :body], + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestApproval, :cluster) => [:name, :body], + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestStatus, :cluster) => [:name, :body], + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequest, :cluster) => [:name, :body], + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestApproval, :cluster) => [:name, :body], + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestStatus, :cluster) => [:name, :body], + (K8sCoordinationK8sIoV1, :create, :Lease, :namespaced) => [:namespace, :body], + (K8sCoordinationK8sIoV1, :delete, :Lease, :namespaced) => [:namespace, :name], + (K8sCoordinationK8sIoV1, :deletecollection, :Lease, :namespaced) => [:namespace], + (K8sCoordinationK8sIoV1, :get, :Lease, :namespaced) => [:namespace, :name], + (K8sCoordinationK8sIoV1, :list, :Lease, :allns) => Symbol[], + (K8sCoordinationK8sIoV1, :list, :Lease, :namespaced) => [:namespace], + (K8sCoordinationK8sIoV1, :patch, :Lease, :namespaced) => [:namespace, :name, :body], + (K8sCoordinationK8sIoV1, :replace, :Lease, :namespaced) => [:namespace, :name, :body], + (K8sDiscoveryK8sIoV1, :create, :EndpointSlice, :namespaced) => [:namespace, :body], + (K8sDiscoveryK8sIoV1, :delete, :EndpointSlice, :namespaced) => [:namespace, :name], + (K8sDiscoveryK8sIoV1, :deletecollection, :EndpointSlice, :namespaced) => [:namespace], + (K8sDiscoveryK8sIoV1, :get, :EndpointSlice, :namespaced) => [:namespace, :name], + (K8sDiscoveryK8sIoV1, :list, :EndpointSlice, :allns) => Symbol[], + (K8sDiscoveryK8sIoV1, :list, :EndpointSlice, :namespaced) => [:namespace], + (K8sDiscoveryK8sIoV1, :patch, :EndpointSlice, :namespaced) => [:namespace, :name, :body], + (K8sDiscoveryK8sIoV1, :replace, :EndpointSlice, :namespaced) => [:namespace, :name, :body], + (K8sEventsK8sIoV1, :create, :Event, :namespaced) => [:namespace, :body], + (K8sEventsK8sIoV1, :delete, :Event, :namespaced) => [:namespace, :name], + (K8sEventsK8sIoV1, :deletecollection, :Event, :namespaced) => [:namespace], + (K8sEventsK8sIoV1, :get, :Event, :namespaced) => [:namespace, :name], + (K8sEventsK8sIoV1, :list, :Event, :allns) => Symbol[], + (K8sEventsK8sIoV1, :list, :Event, :namespaced) => [:namespace], + (K8sEventsK8sIoV1, :patch, :Event, :namespaced) => [:namespace, :name, :body], + (K8sEventsK8sIoV1, :replace, :Event, :namespaced) => [:namespace, :name, :body], + (K8sMetricsK8sIoV1beta1, :get, :NodeMetrics, :cluster) => [:name], + (K8sMetricsK8sIoV1beta1, :get, :PodMetrics, :namespaced) => [:namespace, :name], + (K8sMetricsK8sIoV1beta1, :list, :NodeMetrics, :cluster) => Symbol[], + (K8sMetricsK8sIoV1beta1, :list, :PodMetrics, :allns) => Symbol[], + (K8sMetricsK8sIoV1beta1, :list, :PodMetrics, :namespaced) => [:namespace], + (K8sNetworkingK8sIoV1, :create, :IPAddress, :cluster) => [:body], + (K8sNetworkingK8sIoV1, :create, :Ingress, :namespaced) => [:namespace, :body], + (K8sNetworkingK8sIoV1, :create, :IngressClass, :cluster) => [:body], + (K8sNetworkingK8sIoV1, :create, :NetworkPolicy, :namespaced) => [:namespace, :body], + (K8sNetworkingK8sIoV1, :create, :ServiceCIDR, :cluster) => [:body], + (K8sNetworkingK8sIoV1, :delete, :IPAddress, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :delete, :Ingress, :namespaced) => [:namespace, :name], + (K8sNetworkingK8sIoV1, :delete, :IngressClass, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :delete, :NetworkPolicy, :namespaced) => [:namespace, :name], + (K8sNetworkingK8sIoV1, :delete, :ServiceCIDR, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :deletecollection, :IPAddress, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :deletecollection, :Ingress, :namespaced) => [:namespace], + (K8sNetworkingK8sIoV1, :deletecollection, :IngressClass, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :deletecollection, :NetworkPolicy, :namespaced) => [:namespace], + (K8sNetworkingK8sIoV1, :deletecollection, :ServiceCIDR, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :get, :IPAddress, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :get, :Ingress, :namespaced) => [:namespace, :name], + (K8sNetworkingK8sIoV1, :get, :IngressClass, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :get, :IngressStatus, :namespaced) => [:namespace, :name], + (K8sNetworkingK8sIoV1, :get, :NetworkPolicy, :namespaced) => [:namespace, :name], + (K8sNetworkingK8sIoV1, :get, :ServiceCIDR, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :get, :ServiceCIDRStatus, :cluster) => [:name], + (K8sNetworkingK8sIoV1, :list, :IPAddress, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :list, :Ingress, :allns) => Symbol[], + (K8sNetworkingK8sIoV1, :list, :Ingress, :namespaced) => [:namespace], + (K8sNetworkingK8sIoV1, :list, :IngressClass, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :list, :NetworkPolicy, :allns) => Symbol[], + (K8sNetworkingK8sIoV1, :list, :NetworkPolicy, :namespaced) => [:namespace], + (K8sNetworkingK8sIoV1, :list, :ServiceCIDR, :cluster) => Symbol[], + (K8sNetworkingK8sIoV1, :patch, :IPAddress, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :patch, :Ingress, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :patch, :IngressClass, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :patch, :IngressStatus, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :patch, :NetworkPolicy, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDR, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDRStatus, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :replace, :IPAddress, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :replace, :Ingress, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :replace, :IngressClass, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :replace, :IngressStatus, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :replace, :NetworkPolicy, :namespaced) => [:namespace, :name, :body], + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDR, :cluster) => [:name, :body], + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDRStatus, :cluster) => [:name, :body], + (K8sNodeK8sIoV1, :create, :RuntimeClass, :cluster) => [:body], + (K8sNodeK8sIoV1, :delete, :RuntimeClass, :cluster) => [:name], + (K8sNodeK8sIoV1, :deletecollection, :RuntimeClass, :cluster) => Symbol[], + (K8sNodeK8sIoV1, :get, :RuntimeClass, :cluster) => [:name], + (K8sNodeK8sIoV1, :list, :RuntimeClass, :cluster) => Symbol[], + (K8sNodeK8sIoV1, :patch, :RuntimeClass, :cluster) => [:name, :body], + (K8sNodeK8sIoV1, :replace, :RuntimeClass, :cluster) => [:name, :body], + (K8sPolicyV1, :create, :PodDisruptionBudget, :namespaced) => [:namespace, :body], + (K8sPolicyV1, :delete, :PodDisruptionBudget, :namespaced) => [:namespace, :name], + (K8sPolicyV1, :deletecollection, :PodDisruptionBudget, :namespaced) => [:namespace], + (K8sPolicyV1, :get, :PodDisruptionBudget, :namespaced) => [:namespace, :name], + (K8sPolicyV1, :get, :PodDisruptionBudgetStatus, :namespaced) => [:namespace, :name], + (K8sPolicyV1, :list, :PodDisruptionBudget, :allns) => Symbol[], + (K8sPolicyV1, :list, :PodDisruptionBudget, :namespaced) => [:namespace], + (K8sPolicyV1, :patch, :PodDisruptionBudget, :namespaced) => [:namespace, :name, :body], + (K8sPolicyV1, :patch, :PodDisruptionBudgetStatus, :namespaced) => [:namespace, :name, :body], + (K8sPolicyV1, :replace, :PodDisruptionBudget, :namespaced) => [:namespace, :name, :body], + (K8sPolicyV1, :replace, :PodDisruptionBudgetStatus, :namespaced) => [:namespace, :name, :body], + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRole, :cluster) => [:body], + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRoleBinding, :cluster) => [:body], + (K8sRbacAuthorizationK8sIoV1, :create, :Role, :namespaced) => [:namespace, :body], + (K8sRbacAuthorizationK8sIoV1, :create, :RoleBinding, :namespaced) => [:namespace, :body], + (K8sRbacAuthorizationK8sIoV1, :delete, :ClusterRole, :cluster) => [:name], + (K8sRbacAuthorizationK8sIoV1, :delete, :ClusterRoleBinding, :cluster) => [:name], + (K8sRbacAuthorizationK8sIoV1, :delete, :Role, :namespaced) => [:namespace, :name], + (K8sRbacAuthorizationK8sIoV1, :delete, :RoleBinding, :namespaced) => [:namespace, :name], + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :ClusterRole, :cluster) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :ClusterRoleBinding, :cluster) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :Role, :namespaced) => [:namespace], + (K8sRbacAuthorizationK8sIoV1, :deletecollection, :RoleBinding, :namespaced) => [:namespace], + (K8sRbacAuthorizationK8sIoV1, :get, :ClusterRole, :cluster) => [:name], + (K8sRbacAuthorizationK8sIoV1, :get, :ClusterRoleBinding, :cluster) => [:name], + (K8sRbacAuthorizationK8sIoV1, :get, :Role, :namespaced) => [:namespace, :name], + (K8sRbacAuthorizationK8sIoV1, :get, :RoleBinding, :namespaced) => [:namespace, :name], + (K8sRbacAuthorizationK8sIoV1, :list, :ClusterRole, :cluster) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :list, :ClusterRoleBinding, :cluster) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :list, :Role, :allns) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :list, :Role, :namespaced) => [:namespace], + (K8sRbacAuthorizationK8sIoV1, :list, :RoleBinding, :allns) => Symbol[], + (K8sRbacAuthorizationK8sIoV1, :list, :RoleBinding, :namespaced) => [:namespace], + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRole, :cluster) => [:name, :body], + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRoleBinding, :cluster) => [:name, :body], + (K8sRbacAuthorizationK8sIoV1, :patch, :Role, :namespaced) => [:namespace, :name, :body], + (K8sRbacAuthorizationK8sIoV1, :patch, :RoleBinding, :namespaced) => [:namespace, :name, :body], + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRole, :cluster) => [:name, :body], + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRoleBinding, :cluster) => [:name, :body], + (K8sRbacAuthorizationK8sIoV1, :replace, :Role, :namespaced) => [:namespace, :name, :body], + (K8sRbacAuthorizationK8sIoV1, :replace, :RoleBinding, :namespaced) => [:namespace, :name, :body], + (K8sSchedulingK8sIoV1, :create, :PriorityClass, :cluster) => [:body], + (K8sSchedulingK8sIoV1, :delete, :PriorityClass, :cluster) => [:name], + (K8sSchedulingK8sIoV1, :deletecollection, :PriorityClass, :cluster) => Symbol[], + (K8sSchedulingK8sIoV1, :get, :PriorityClass, :cluster) => [:name], + (K8sSchedulingK8sIoV1, :list, :PriorityClass, :cluster) => Symbol[], + (K8sSchedulingK8sIoV1, :patch, :PriorityClass, :cluster) => [:name, :body], + (K8sSchedulingK8sIoV1, :replace, :PriorityClass, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :create, :CSIDriver, :cluster) => [:body], + (K8sStorageK8sIoV1, :create, :CSINode, :cluster) => [:body], + (K8sStorageK8sIoV1, :create, :CSIStorageCapacity, :namespaced) => [:namespace, :body], + (K8sStorageK8sIoV1, :create, :StorageClass, :cluster) => [:body], + (K8sStorageK8sIoV1, :create, :VolumeAttachment, :cluster) => [:body], + (K8sStorageK8sIoV1, :create, :VolumeAttributesClass, :cluster) => [:body], + (K8sStorageK8sIoV1, :delete, :CSIDriver, :cluster) => [:name], + (K8sStorageK8sIoV1, :delete, :CSINode, :cluster) => [:name], + (K8sStorageK8sIoV1, :delete, :CSIStorageCapacity, :namespaced) => [:namespace, :name], + (K8sStorageK8sIoV1, :delete, :StorageClass, :cluster) => [:name], + (K8sStorageK8sIoV1, :delete, :VolumeAttachment, :cluster) => [:name], + (K8sStorageK8sIoV1, :delete, :VolumeAttributesClass, :cluster) => [:name], + (K8sStorageK8sIoV1, :deletecollection, :CSIDriver, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :deletecollection, :CSINode, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :deletecollection, :CSIStorageCapacity, :namespaced) => [:namespace], + (K8sStorageK8sIoV1, :deletecollection, :StorageClass, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :deletecollection, :VolumeAttachment, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :deletecollection, :VolumeAttributesClass, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :get, :CSIDriver, :cluster) => [:name], + (K8sStorageK8sIoV1, :get, :CSINode, :cluster) => [:name], + (K8sStorageK8sIoV1, :get, :CSIStorageCapacity, :namespaced) => [:namespace, :name], + (K8sStorageK8sIoV1, :get, :StorageClass, :cluster) => [:name], + (K8sStorageK8sIoV1, :get, :VolumeAttachment, :cluster) => [:name], + (K8sStorageK8sIoV1, :get, :VolumeAttachmentStatus, :cluster) => [:name], + (K8sStorageK8sIoV1, :get, :VolumeAttributesClass, :cluster) => [:name], + (K8sStorageK8sIoV1, :list, :CSIDriver, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :list, :CSINode, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :list, :CSIStorageCapacity, :allns) => Symbol[], + (K8sStorageK8sIoV1, :list, :CSIStorageCapacity, :namespaced) => [:namespace], + (K8sStorageK8sIoV1, :list, :StorageClass, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :list, :VolumeAttachment, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :list, :VolumeAttributesClass, :cluster) => Symbol[], + (K8sStorageK8sIoV1, :patch, :CSIDriver, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :patch, :CSINode, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :patch, :CSIStorageCapacity, :namespaced) => [:namespace, :name, :body], + (K8sStorageK8sIoV1, :patch, :StorageClass, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :patch, :VolumeAttachment, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :patch, :VolumeAttachmentStatus, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :patch, :VolumeAttributesClass, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :CSIDriver, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :CSINode, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :CSIStorageCapacity, :namespaced) => [:namespace, :name, :body], + (K8sStorageK8sIoV1, :replace, :StorageClass, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :VolumeAttachment, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :VolumeAttachmentStatus, :cluster) => [:name, :body], + (K8sStorageK8sIoV1, :replace, :VolumeAttributesClass, :cluster) => [:name, :body], + (K8sV1, :create, :Binding, :namespaced) => [:namespace, :body], + (K8sV1, :create, :ConfigMap, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Endpoints, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Event, :namespaced) => [:namespace, :body], + (K8sV1, :create, :LimitRange, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Namespace, :cluster) => [:body], + (K8sV1, :create, :Node, :cluster) => [:body], + (K8sV1, :create, :PersistentVolume, :cluster) => [:body], + (K8sV1, :create, :PersistentVolumeClaim, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Pod, :namespaced) => [:namespace, :body], + (K8sV1, :create, :PodBinding, :namespaced) => [:namespace, :name, :body], + (K8sV1, :create, :PodEviction, :namespaced) => [:namespace, :name, :body], + (K8sV1, :create, :PodTemplate, :namespaced) => [:namespace, :body], + (K8sV1, :create, :ReplicationController, :namespaced) => [:namespace, :body], + (K8sV1, :create, :ResourceQuota, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Secret, :namespaced) => [:namespace, :body], + (K8sV1, :create, :Service, :namespaced) => [:namespace, :body], + (K8sV1, :create, :ServiceAccount, :namespaced) => [:namespace, :body], + (K8sV1, :create, :ServiceAccountToken, :namespaced) => [:namespace, :name, :body], + (K8sV1, :delete, :ConfigMap, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Endpoints, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Event, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :LimitRange, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Namespace, :cluster) => [:name], + (K8sV1, :delete, :Node, :cluster) => [:name], + (K8sV1, :delete, :PersistentVolume, :cluster) => [:name], + (K8sV1, :delete, :PersistentVolumeClaim, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Pod, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :PodTemplate, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :ReplicationController, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :ResourceQuota, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Secret, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :Service, :namespaced) => [:namespace, :name], + (K8sV1, :delete, :ServiceAccount, :namespaced) => [:namespace, :name], + (K8sV1, :deletecollection, :ConfigMap, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Endpoints, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Event, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :LimitRange, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Node, :cluster) => Symbol[], + (K8sV1, :deletecollection, :PersistentVolume, :cluster) => Symbol[], + (K8sV1, :deletecollection, :PersistentVolumeClaim, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Pod, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :PodTemplate, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :ReplicationController, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :ResourceQuota, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Secret, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :Service, :namespaced) => [:namespace], + (K8sV1, :deletecollection, :ServiceAccount, :namespaced) => [:namespace], + (K8sV1, :get, :ComponentStatus, :cluster) => [:name], + (K8sV1, :get, :ConfigMap, :namespaced) => [:namespace, :name], + (K8sV1, :get, :Endpoints, :namespaced) => [:namespace, :name], + (K8sV1, :get, :Event, :namespaced) => [:namespace, :name], + (K8sV1, :get, :LimitRange, :namespaced) => [:namespace, :name], + (K8sV1, :get, :Namespace, :cluster) => [:name], + (K8sV1, :get, :NamespaceStatus, :cluster) => [:name], + (K8sV1, :get, :Node, :cluster) => [:name], + (K8sV1, :get, :NodeStatus, :cluster) => [:name], + (K8sV1, :get, :PersistentVolume, :cluster) => [:name], + (K8sV1, :get, :PersistentVolumeClaim, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PersistentVolumeClaimStatus, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PersistentVolumeStatus, :cluster) => [:name], + (K8sV1, :get, :Pod, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PodEphemeralcontainers, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PodLog, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PodResize, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PodStatus, :namespaced) => [:namespace, :name], + (K8sV1, :get, :PodTemplate, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ReplicationController, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ReplicationControllerScale, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ReplicationControllerStatus, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ResourceQuota, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ResourceQuotaStatus, :namespaced) => [:namespace, :name], + (K8sV1, :get, :Secret, :namespaced) => [:namespace, :name], + (K8sV1, :get, :Service, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ServiceAccount, :namespaced) => [:namespace, :name], + (K8sV1, :get, :ServiceStatus, :namespaced) => [:namespace, :name], + (K8sV1, :list, :ComponentStatus, :cluster) => Symbol[], + (K8sV1, :list, :ConfigMap, :allns) => Symbol[], + (K8sV1, :list, :ConfigMap, :namespaced) => [:namespace], + (K8sV1, :list, :Endpoints, :allns) => Symbol[], + (K8sV1, :list, :Endpoints, :namespaced) => [:namespace], + (K8sV1, :list, :Event, :allns) => Symbol[], + (K8sV1, :list, :Event, :namespaced) => [:namespace], + (K8sV1, :list, :LimitRange, :allns) => Symbol[], + (K8sV1, :list, :LimitRange, :namespaced) => [:namespace], + (K8sV1, :list, :Namespace, :cluster) => Symbol[], + (K8sV1, :list, :Node, :cluster) => Symbol[], + (K8sV1, :list, :PersistentVolume, :cluster) => Symbol[], + (K8sV1, :list, :PersistentVolumeClaim, :allns) => Symbol[], + (K8sV1, :list, :PersistentVolumeClaim, :namespaced) => [:namespace], + (K8sV1, :list, :Pod, :allns) => Symbol[], + (K8sV1, :list, :Pod, :namespaced) => [:namespace], + (K8sV1, :list, :PodTemplate, :allns) => Symbol[], + (K8sV1, :list, :PodTemplate, :namespaced) => [:namespace], + (K8sV1, :list, :ReplicationController, :allns) => Symbol[], + (K8sV1, :list, :ReplicationController, :namespaced) => [:namespace], + (K8sV1, :list, :ResourceQuota, :allns) => Symbol[], + (K8sV1, :list, :ResourceQuota, :namespaced) => [:namespace], + (K8sV1, :list, :Secret, :allns) => Symbol[], + (K8sV1, :list, :Secret, :namespaced) => [:namespace], + (K8sV1, :list, :Service, :allns) => Symbol[], + (K8sV1, :list, :Service, :namespaced) => [:namespace], + (K8sV1, :list, :ServiceAccount, :allns) => Symbol[], + (K8sV1, :list, :ServiceAccount, :namespaced) => [:namespace], + (K8sV1, :patch, :ConfigMap, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :Endpoints, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :Event, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :LimitRange, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :Namespace, :cluster) => [:name, :body], + (K8sV1, :patch, :NamespaceStatus, :cluster) => [:name, :body], + (K8sV1, :patch, :Node, :cluster) => [:name, :body], + (K8sV1, :patch, :NodeStatus, :cluster) => [:name, :body], + (K8sV1, :patch, :PersistentVolume, :cluster) => [:name, :body], + (K8sV1, :patch, :PersistentVolumeClaim, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PersistentVolumeClaimStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PersistentVolumeStatus, :cluster) => [:name, :body], + (K8sV1, :patch, :Pod, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PodEphemeralcontainers, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PodResize, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PodStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :PodTemplate, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ReplicationController, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ReplicationControllerScale, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ReplicationControllerStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ResourceQuota, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ResourceQuotaStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :Secret, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :Service, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ServiceAccount, :namespaced) => [:namespace, :name, :body], + (K8sV1, :patch, :ServiceStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ConfigMap, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :Endpoints, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :Event, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :LimitRange, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :Namespace, :cluster) => [:name, :body], + (K8sV1, :replace, :NamespaceFinalize, :cluster) => [:name, :body], + (K8sV1, :replace, :NamespaceStatus, :cluster) => [:name, :body], + (K8sV1, :replace, :Node, :cluster) => [:name, :body], + (K8sV1, :replace, :NodeStatus, :cluster) => [:name, :body], + (K8sV1, :replace, :PersistentVolume, :cluster) => [:name, :body], + (K8sV1, :replace, :PersistentVolumeClaim, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PersistentVolumeClaimStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PersistentVolumeStatus, :cluster) => [:name, :body], + (K8sV1, :replace, :Pod, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PodEphemeralcontainers, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PodResize, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PodStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :PodTemplate, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ReplicationController, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ReplicationControllerScale, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ReplicationControllerStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ResourceQuota, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ResourceQuotaStatus, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :Secret, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :Service, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ServiceAccount, :namespaced) => [:namespace, :name, :body], + (K8sV1, :replace, :ServiceStatus, :namespaced) => [:namespace, :name, :body], +) + +""" +For each [`OPS`] entry with a required request body, the media types the +document accepts and the generated body type for each. + +`update!` needs the mapping, not just a list: a PATCH takes the `Patch` model +(an open object) for merge, strategic-merge and apply patches, but the +`JSONPatch` array for `application/json-patch+json` — one schema per media +type since patch_k8s_spec.jq §6. It is also what lets a wrong `content_type` +be reported as such — k8s documents no plain `application/json` for a PATCH — +instead of failing deep inside media selection. +""" +const OP_BODIES = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}( + (K8sApiextensionsK8sIoV1, :create, :CustomResourceDefinition, :cluster) => Dict{String,Type}("application/json" => K8sApiextensionsK8sIoV1.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition), + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinition, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sApiextensionsK8sIoV1, :patch, :CustomResourceDefinitionStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sApiextensionsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinition, :cluster) => Dict{String,Type}("application/json" => K8sApiextensionsK8sIoV1.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition), + (K8sApiextensionsK8sIoV1, :replace, :CustomResourceDefinitionStatus, :cluster) => Dict{String,Type}("application/json" => K8sApiextensionsK8sIoV1.IoK8sApiextensionsApiserverPkgApisApiextensionsV1CustomResourceDefinition), + (K8sApiregistrationK8sIoV1, :create, :APIService, :cluster) => Dict{String,Type}("application/json" => K8sApiregistrationK8sIoV1.IoK8sKubeAggregatorPkgApisApiregistrationV1APIService), + (K8sApiregistrationK8sIoV1, :patch, :APIService, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sApiregistrationK8sIoV1, :patch, :APIServiceStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sApiregistrationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sApiregistrationK8sIoV1, :replace, :APIService, :cluster) => Dict{String,Type}("application/json" => K8sApiregistrationK8sIoV1.IoK8sKubeAggregatorPkgApisApiregistrationV1APIService), + (K8sApiregistrationK8sIoV1, :replace, :APIServiceStatus, :cluster) => Dict{String,Type}("application/json" => K8sApiregistrationK8sIoV1.IoK8sKubeAggregatorPkgApisApiregistrationV1APIService), + (K8sAppsV1, :create, :ControllerRevision, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1ControllerRevision), + (K8sAppsV1, :create, :DaemonSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1DaemonSet), + (K8sAppsV1, :create, :Deployment, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1Deployment), + (K8sAppsV1, :create, :ReplicaSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1ReplicaSet), + (K8sAppsV1, :create, :StatefulSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1StatefulSet), + (K8sAppsV1, :patch, :ControllerRevision, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :DaemonSet, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :DaemonSetStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :Deployment, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :DeploymentScale, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :DeploymentStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :ReplicaSet, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :ReplicaSetScale, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :ReplicaSetStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :StatefulSet, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :StatefulSetScale, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :patch, :StatefulSetStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAppsV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAppsV1, :replace, :ControllerRevision, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1ControllerRevision), + (K8sAppsV1, :replace, :DaemonSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1DaemonSet), + (K8sAppsV1, :replace, :DaemonSetStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1DaemonSet), + (K8sAppsV1, :replace, :Deployment, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1Deployment), + (K8sAppsV1, :replace, :DeploymentScale, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAutoscalingV1Scale), + (K8sAppsV1, :replace, :DeploymentStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1Deployment), + (K8sAppsV1, :replace, :ReplicaSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1ReplicaSet), + (K8sAppsV1, :replace, :ReplicaSetScale, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAutoscalingV1Scale), + (K8sAppsV1, :replace, :ReplicaSetStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1ReplicaSet), + (K8sAppsV1, :replace, :StatefulSet, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1StatefulSet), + (K8sAppsV1, :replace, :StatefulSetScale, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAutoscalingV1Scale), + (K8sAppsV1, :replace, :StatefulSetStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAppsV1.IoK8sApiAppsV1StatefulSet), + (K8sAutoscalingV1, :create, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV1.IoK8sApiAutoscalingV1HorizontalPodAutoscaler), + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAutoscalingV1, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAutoscalingV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV1.IoK8sApiAutoscalingV1HorizontalPodAutoscaler), + (K8sAutoscalingV1, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV1.IoK8sApiAutoscalingV1HorizontalPodAutoscaler), + (K8sAutoscalingV2, :create, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV2.IoK8sApiAutoscalingV2HorizontalPodAutoscaler), + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAutoscalingV2, :patch, :HorizontalPodAutoscalerStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sAutoscalingV2.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscaler, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV2.IoK8sApiAutoscalingV2HorizontalPodAutoscaler), + (K8sAutoscalingV2, :replace, :HorizontalPodAutoscalerStatus, :namespaced) => Dict{String,Type}("application/json" => K8sAutoscalingV2.IoK8sApiAutoscalingV2HorizontalPodAutoscaler), + (K8sBatchV1, :create, :CronJob, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1CronJob), + (K8sBatchV1, :create, :Job, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1Job), + (K8sBatchV1, :patch, :CronJob, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sBatchV1, :patch, :CronJobStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sBatchV1, :patch, :Job, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sBatchV1, :patch, :JobStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sBatchV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sBatchV1, :replace, :CronJob, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1CronJob), + (K8sBatchV1, :replace, :CronJobStatus, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1CronJob), + (K8sBatchV1, :replace, :Job, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1Job), + (K8sBatchV1, :replace, :JobStatus, :namespaced) => Dict{String,Type}("application/json" => K8sBatchV1.IoK8sApiBatchV1Job), + (K8sCertificatesK8sIoV1, :create, :CertificateSigningRequest, :cluster) => Dict{String,Type}("application/json" => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequest), + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequest, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestApproval, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sCertificatesK8sIoV1, :patch, :CertificateSigningRequestStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sCertificatesK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequest, :cluster) => Dict{String,Type}("application/json" => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequest), + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestApproval, :cluster) => Dict{String,Type}("application/json" => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequest), + (K8sCertificatesK8sIoV1, :replace, :CertificateSigningRequestStatus, :cluster) => Dict{String,Type}("application/json" => K8sCertificatesK8sIoV1.IoK8sApiCertificatesV1CertificateSigningRequest), + (K8sCoordinationK8sIoV1, :create, :Lease, :namespaced) => Dict{String,Type}("application/json" => K8sCoordinationK8sIoV1.IoK8sApiCoordinationV1Lease), + (K8sCoordinationK8sIoV1, :patch, :Lease, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sCoordinationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sCoordinationK8sIoV1, :replace, :Lease, :namespaced) => Dict{String,Type}("application/json" => K8sCoordinationK8sIoV1.IoK8sApiCoordinationV1Lease), + (K8sDiscoveryK8sIoV1, :create, :EndpointSlice, :namespaced) => Dict{String,Type}("application/json" => K8sDiscoveryK8sIoV1.IoK8sApiDiscoveryV1EndpointSlice), + (K8sDiscoveryK8sIoV1, :patch, :EndpointSlice, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sDiscoveryK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sDiscoveryK8sIoV1, :replace, :EndpointSlice, :namespaced) => Dict{String,Type}("application/json" => K8sDiscoveryK8sIoV1.IoK8sApiDiscoveryV1EndpointSlice), + (K8sEventsK8sIoV1, :create, :Event, :namespaced) => Dict{String,Type}("application/json" => K8sEventsK8sIoV1.IoK8sApiEventsV1Event), + (K8sEventsK8sIoV1, :patch, :Event, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sEventsK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sEventsK8sIoV1, :replace, :Event, :namespaced) => Dict{String,Type}("application/json" => K8sEventsK8sIoV1.IoK8sApiEventsV1Event), + (K8sNetworkingK8sIoV1, :create, :IPAddress, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IPAddress), + (K8sNetworkingK8sIoV1, :create, :Ingress, :namespaced) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1Ingress), + (K8sNetworkingK8sIoV1, :create, :IngressClass, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IngressClass), + (K8sNetworkingK8sIoV1, :create, :NetworkPolicy, :namespaced) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1NetworkPolicy), + (K8sNetworkingK8sIoV1, :create, :ServiceCIDR, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1ServiceCIDR), + (K8sNetworkingK8sIoV1, :patch, :IPAddress, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :Ingress, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :IngressClass, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :IngressStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :NetworkPolicy, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDR, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :patch, :ServiceCIDRStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNetworkingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNetworkingK8sIoV1, :replace, :IPAddress, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IPAddress), + (K8sNetworkingK8sIoV1, :replace, :Ingress, :namespaced) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1Ingress), + (K8sNetworkingK8sIoV1, :replace, :IngressClass, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1IngressClass), + (K8sNetworkingK8sIoV1, :replace, :IngressStatus, :namespaced) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1Ingress), + (K8sNetworkingK8sIoV1, :replace, :NetworkPolicy, :namespaced) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1NetworkPolicy), + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDR, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1ServiceCIDR), + (K8sNetworkingK8sIoV1, :replace, :ServiceCIDRStatus, :cluster) => Dict{String,Type}("application/json" => K8sNetworkingK8sIoV1.IoK8sApiNetworkingV1ServiceCIDR), + (K8sNodeK8sIoV1, :create, :RuntimeClass, :cluster) => Dict{String,Type}("application/json" => K8sNodeK8sIoV1.IoK8sApiNodeV1RuntimeClass), + (K8sNodeK8sIoV1, :patch, :RuntimeClass, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sNodeK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sNodeK8sIoV1, :replace, :RuntimeClass, :cluster) => Dict{String,Type}("application/json" => K8sNodeK8sIoV1.IoK8sApiNodeV1RuntimeClass), + (K8sPolicyV1, :create, :PodDisruptionBudget, :namespaced) => Dict{String,Type}("application/json" => K8sPolicyV1.IoK8sApiPolicyV1PodDisruptionBudget), + (K8sPolicyV1, :patch, :PodDisruptionBudget, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sPolicyV1, :patch, :PodDisruptionBudgetStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sPolicyV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sPolicyV1, :replace, :PodDisruptionBudget, :namespaced) => Dict{String,Type}("application/json" => K8sPolicyV1.IoK8sApiPolicyV1PodDisruptionBudget), + (K8sPolicyV1, :replace, :PodDisruptionBudgetStatus, :namespaced) => Dict{String,Type}("application/json" => K8sPolicyV1.IoK8sApiPolicyV1PodDisruptionBudget), + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRole, :cluster) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRole), + (K8sRbacAuthorizationK8sIoV1, :create, :ClusterRoleBinding, :cluster) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRoleBinding), + (K8sRbacAuthorizationK8sIoV1, :create, :Role, :namespaced) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1Role), + (K8sRbacAuthorizationK8sIoV1, :create, :RoleBinding, :namespaced) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1RoleBinding), + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRole, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sRbacAuthorizationK8sIoV1, :patch, :ClusterRoleBinding, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sRbacAuthorizationK8sIoV1, :patch, :Role, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sRbacAuthorizationK8sIoV1, :patch, :RoleBinding, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sRbacAuthorizationK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRole, :cluster) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRole), + (K8sRbacAuthorizationK8sIoV1, :replace, :ClusterRoleBinding, :cluster) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1ClusterRoleBinding), + (K8sRbacAuthorizationK8sIoV1, :replace, :Role, :namespaced) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1Role), + (K8sRbacAuthorizationK8sIoV1, :replace, :RoleBinding, :namespaced) => Dict{String,Type}("application/json" => K8sRbacAuthorizationK8sIoV1.IoK8sApiRbacV1RoleBinding), + (K8sSchedulingK8sIoV1, :create, :PriorityClass, :cluster) => Dict{String,Type}("application/json" => K8sSchedulingK8sIoV1.IoK8sApiSchedulingV1PriorityClass), + (K8sSchedulingK8sIoV1, :patch, :PriorityClass, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sSchedulingK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sSchedulingK8sIoV1, :replace, :PriorityClass, :cluster) => Dict{String,Type}("application/json" => K8sSchedulingK8sIoV1.IoK8sApiSchedulingV1PriorityClass), + (K8sStorageK8sIoV1, :create, :CSIDriver, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIDriver), + (K8sStorageK8sIoV1, :create, :CSINode, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSINode), + (K8sStorageK8sIoV1, :create, :CSIStorageCapacity, :namespaced) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIStorageCapacity), + (K8sStorageK8sIoV1, :create, :StorageClass, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1StorageClass), + (K8sStorageK8sIoV1, :create, :VolumeAttachment, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttachment), + (K8sStorageK8sIoV1, :create, :VolumeAttributesClass, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttributesClass), + (K8sStorageK8sIoV1, :patch, :CSIDriver, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :CSINode, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :CSIStorageCapacity, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :StorageClass, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :VolumeAttachment, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :VolumeAttachmentStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :patch, :VolumeAttributesClass, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sStorageK8sIoV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sStorageK8sIoV1, :replace, :CSIDriver, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIDriver), + (K8sStorageK8sIoV1, :replace, :CSINode, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSINode), + (K8sStorageK8sIoV1, :replace, :CSIStorageCapacity, :namespaced) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1CSIStorageCapacity), + (K8sStorageK8sIoV1, :replace, :StorageClass, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1StorageClass), + (K8sStorageK8sIoV1, :replace, :VolumeAttachment, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttachment), + (K8sStorageK8sIoV1, :replace, :VolumeAttachmentStatus, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttachment), + (K8sStorageK8sIoV1, :replace, :VolumeAttributesClass, :cluster) => Dict{String,Type}("application/json" => K8sStorageK8sIoV1.IoK8sApiStorageV1VolumeAttributesClass), + (K8sV1, :create, :Binding, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Binding), + (K8sV1, :create, :ConfigMap, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ConfigMap), + (K8sV1, :create, :Endpoints, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Endpoints), + (K8sV1, :create, :Event, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Event), + (K8sV1, :create, :LimitRange, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1LimitRange), + (K8sV1, :create, :Namespace, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Namespace), + (K8sV1, :create, :Node, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Node), + (K8sV1, :create, :PersistentVolume, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolume), + (K8sV1, :create, :PersistentVolumeClaim, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolumeClaim), + (K8sV1, :create, :Pod, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Pod), + (K8sV1, :create, :PodBinding, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Binding), + (K8sV1, :create, :PodEviction, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiPolicyV1Eviction), + (K8sV1, :create, :PodTemplate, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PodTemplate), + (K8sV1, :create, :ReplicationController, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ReplicationController), + (K8sV1, :create, :ResourceQuota, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ResourceQuota), + (K8sV1, :create, :Secret, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Secret), + (K8sV1, :create, :Service, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Service), + (K8sV1, :create, :ServiceAccount, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ServiceAccount), + (K8sV1, :create, :ServiceAccountToken, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiAuthenticationV1TokenRequest), + (K8sV1, :patch, :ConfigMap, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Endpoints, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Event, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :LimitRange, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Namespace, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :NamespaceStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Node, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :NodeStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PersistentVolume, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PersistentVolumeClaim, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PersistentVolumeClaimStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PersistentVolumeStatus, :cluster) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Pod, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PodEphemeralcontainers, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PodResize, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PodStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :PodTemplate, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ReplicationController, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ReplicationControllerScale, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ReplicationControllerStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ResourceQuota, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ResourceQuotaStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Secret, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :Service, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ServiceAccount, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :patch, :ServiceStatus, :namespaced) => Dict{String,Type}("application/apply-patch+cbor" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/apply-patch+yaml" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/json-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1JSONPatch, "application/merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch, "application/strategic-merge-patch+json" => K8sV1.IoK8sApimachineryPkgApisMetaV1Patch), + (K8sV1, :replace, :ConfigMap, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ConfigMap), + (K8sV1, :replace, :Endpoints, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Endpoints), + (K8sV1, :replace, :Event, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Event), + (K8sV1, :replace, :LimitRange, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1LimitRange), + (K8sV1, :replace, :Namespace, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Namespace), + (K8sV1, :replace, :NamespaceFinalize, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Namespace), + (K8sV1, :replace, :NamespaceStatus, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Namespace), + (K8sV1, :replace, :Node, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Node), + (K8sV1, :replace, :NodeStatus, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Node), + (K8sV1, :replace, :PersistentVolume, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolume), + (K8sV1, :replace, :PersistentVolumeClaim, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolumeClaim), + (K8sV1, :replace, :PersistentVolumeClaimStatus, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolumeClaim), + (K8sV1, :replace, :PersistentVolumeStatus, :cluster) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PersistentVolume), + (K8sV1, :replace, :Pod, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Pod), + (K8sV1, :replace, :PodEphemeralcontainers, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Pod), + (K8sV1, :replace, :PodResize, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Pod), + (K8sV1, :replace, :PodStatus, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Pod), + (K8sV1, :replace, :PodTemplate, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1PodTemplate), + (K8sV1, :replace, :ReplicationController, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ReplicationController), + (K8sV1, :replace, :ReplicationControllerScale, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiAutoscalingV1Scale), + (K8sV1, :replace, :ReplicationControllerStatus, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ReplicationController), + (K8sV1, :replace, :ResourceQuota, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ResourceQuota), + (K8sV1, :replace, :ResourceQuotaStatus, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ResourceQuota), + (K8sV1, :replace, :Secret, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Secret), + (K8sV1, :replace, :Service, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Service), + (K8sV1, :replace, :ServiceAccount, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1ServiceAccount), + (K8sV1, :replace, :ServiceStatus, :namespaced) => Dict{String,Type}("application/json" => K8sV1.IoK8sApiCoreV1Service), +) diff --git a/src/Kuber.jl b/src/Kuber.jl index 3baa7b69..c68a3bbf 100644 --- a/src/Kuber.jl +++ b/src/Kuber.jl @@ -2,18 +2,22 @@ module Kuber using JSON using OpenAPI -using Downloads - -import OpenAPI: val_format +using HTTP include("ApiImpl/ApiImpl.jl") -import Base: convert, get, put!, delete!, show +import Base: get, put!, delete!, show, showerror include("helpers.jl") +include("register.jl") include("simpleapi.jl") -export KuberContext, set_server, set_ns, set_retries, get_server, get_ns, kuber_type, kuber_obj, @K_str -export get, list, watch, put!, update!, delete!, sel, get_logs, list_namespaced_custom_metrics, list_custom_metrics +export KuberContext, KuberEvent, KuberException, set_server, set_ns, set_retries +export is_retryable +export get_server, get_ns, get_timeout, set_timeout, with_timeout +export get_request_options, set_request_options +export kind_to_type, kuber_type, kuber_obj, kuber_kind, kuber_props +export get, list, watch, put!, update!, delete!, sel, get_logs +export list_namespaced_custom_metrics, list_custom_metrics end # module diff --git a/src/helpers.jl b/src/helpers.jl index 78ddce76..73f5e827 100644 --- a/src/helpers.jl +++ b/src/helpers.jl @@ -1,126 +1,204 @@ const DEFAULT_NAMESPACE = "default" const DEFAULT_URI = "http://localhost:8001" -to_snake_case(o) = to_snake_case(string(o)) -function to_snake_case(camel_case_str::String) - iob = IOBuffer() - for c in camel_case_str - if isuppercase(c) - (iob.size > 0) && write(iob, '_') - write(iob, lowercase(c)) - else - write(iob, c) - end - end - String(take!(iob)) -end +const Runtime = OpenAPI.Runtime -"""delay customized by TPS requirement""" -k8s_delay(tps, max_tries=1) = ExponentialBackOff(n=max_tries, first_delay=(1/tps), factor=1.75, jitter=0.1) +using .ApiImpl: GROUP_MODULES, MODULE_GVS, KIND_TYPES, OPS, OP_PARAMS """ -OpenAPI status codes that can be retried. -0: network error (HTTP was not even attempted) -500-504: unexpected server error +The media type that scopes the watch codec. + +Registering a decoder for it does nothing on its own: codecs match on the +*received* Content-Type and a real apiserver always replies with a bare +`application/json`, even for a watch. Since OpenAPI `1ff9ba8` a streaming call +falls back to the media type the call asked for, so passing +`accept = WATCH_MEDIA` is what makes the codec fire — and it fires for exactly +those calls, leaving buffered calls on the same client decoding typed models. """ -const k8s_retryable_codes = [0, 500, 501, 502, 503, 504] +const WATCH_MEDIA = "application/json;stream=watch" + +const KuberEventStream = Channel{Any} """ -`stream`, if given, is the event channel a watch call streams into. Closing it is -the documented way for a consumer to stop an in-progress watch (see `watch` in -simpleapi.jl), and doing so also surfaces as `is_request_interrupted`. Only treat -`is_request_interrupted` as retryable while that channel is still open, so an -intentional stop isn't mistaken for a transient interruption and retried instead -of being allowed to terminate. + KuberEvent(type, object) + +One item from a watch stream. `type` is `ADDED`, `MODIFIED`, `DELETED`, +`BOOKMARK` or `ERROR`; `object` is the typed model when the kind is known and +the raw JSON object otherwise. + +Kuber-owned rather than the generated `WatchEvent` model, so that `event.type` +keeps working at call sites — the generated field is named `type_`, since +`type` collides with a reserved name. """ -function k8s_retry_cond(s, e, retryable_codes=k8s_retryable_codes; stream::Union{Channel,Nothing}=nothing) - if (e isa OpenAPI.Clients.ApiException) && (e.status in retryable_codes) - return (s, true) - end - if OpenAPI.Clients.is_request_interrupted(e) && (stream === nothing || isopen(stream)) - return (s, true) - end - (s, false) +struct KuberEvent + type::String + object::Any end +show(io::IO, e::KuberEvent) = print(io, "KuberEvent(", e.type, ", ", typeof(e.object), ")") + """ -Retry api call automatically (if `max_tries > 1`) on certain retryable failures. -Backoff to use when retrying k8s APIs. The default minimum is 2 TPS. + _field(x, default=nothing) + +Read a model field that may be `ABSENT`. -`stream`, if given, is passed to `k8s_retry_cond` to distinguish an intentional -watch-stop (channel closed by the consumer) from a transient interruption. +The one user-visible semantic change of the OpenAPI 1.0 models: a field that is +absent from the payload is `ABSENT`, and `nothing` now means an explicit JSON +`null`. The old client collapsed both to `nothing`. """ -k8s_retry(f; max_tries=1, tps=2, stream::Union{Channel,Nothing}=nothing) = - retry(f, delays=k8s_delay(tps,max_tries), check=(s,e)->k8s_retry_cond(s,e; stream=stream))() +_field(x, default = nothing) = x isa Runtime.Absent ? default : x """ -Build keyword arguments for OpenAPI.Clients.Client constructor. -Detects if HTTP.jl backend is available (OpenAPI >= 0.2.1) and uses it by default. + kuber_props(x, default=Dict{String,String}()) -> AbstractDict -Args: -- httplib: Optional HTTP library to use (:http or :downloads). Defaults to HTTP.jl if available. -""" -function _openapi_client_kwargs(httplib::Union{Nothing,Symbol}=nothing) - kwargs = Dict{Symbol,Any}() - if isdefined(OpenAPI.Clients, :HTTPLib) - if httplib === nothing - kwargs[:httplib] = OpenAPI.Clients.HTTPLib.HTTP # Default to HTTP.jl - else - kwargs[:httplib] = httplib - end - end - return kwargs +Read a Kubernetes string map — `metadata.labels`, `metadata.annotations`, +`nodeSelector`, … — as a dictionary. + +k8s declares these as open objects, so the generator gives each one a model type +whose entries live in `additional_properties` rather than making it a plain +`Dict`. This normalizes the shapes a caller can meet: `ABSENT` or `null`, a real +dictionary, or one of those generated structs. + +```julia +kuber_props(pod.metadata.annotations)["my.annotation"] +``` +""" +function kuber_props(x, default = Dict{String,String}()) + x = _field(x) + x === nothing && return default + x isa AbstractDict && return x + hasproperty(x, :additional_properties) || return default + return _field(x.additional_properties, default) end """ -Return appropriate Connection header value based on HTTP backend. + _lookup(obj, name) -> value or nothing -Args: -- httplib: Optional HTTP library being used (:http or :downloads). Defaults to HTTP.jl logic. +One step of a path walk: a field of a model, a key of a dictionary, an index +into a vector, or an entry of an open struct's `additional_properties`. +Everything absent — a missing field, an out-of-range index, `ABSENT`, `null` — +comes back as `nothing`, which is what makes the walk uniform. """ -function _connection_header_value(httplib::Union{Nothing,Symbol}=nothing) - if !isdefined(OpenAPI.Clients, :HTTPLib) - return "close" +function _lookup(obj, name) + if name isa Integer + obj isa AbstractVector || return nothing + checkbounds(Bool, obj, name) || return nothing + return _field(obj[name]) end - effective_lib = httplib === nothing ? OpenAPI.Clients.HTTPLib.HTTP : httplib - return effective_lib === OpenAPI.Clients.HTTPLib.HTTP ? "Keep-Alive" : "close" + if obj isa AbstractDict + return _field(get(obj, name isa Symbol ? String(name) : name, nothing)) + end + sym = Symbol(name) + hasproperty(obj, sym) && return _field(getproperty(obj, sym)) + # a k8s string map (labels, annotations, resource limits) is an open struct, + # so its entries are not fields — reach them by their own name + props = kuber_props(obj, nothing) + props === nothing && return nothing + return _field(get(props, name isa Symbol ? String(name) : name, nothing)) end -const KuberEventStream = Channel{Any} +""" + getpropertyat(obj, path...) + +Walk a path of field names, vector indices and open-struct keys, returning +`nothing` the moment any step is absent. + +The replacement for `OpenAPI.Clients.getpropertyat`, which OpenAPI.jl 1.0 does +not have (`OpenAPIv1ConsumerGaps.md` C2). Deliberately **not exported**: it is a +compatibility shim for consumers porting off 0.2.x, not a shape this API wants +to encourage. + +Two differences from the 0.x version, both forced by the runtime: + +- **`ABSENT` counts as absent.** On 0.x an unset field was `nothing` and 0.x + overrode `Base.hasproperty` to say so. On 1.0 every field exists and an unset + one is `ABSENT`, so a plain `hasproperty` walk answers `true` for everything — + the trap that makes `container_resource` in JuliaRun's `clustermgmt.jl` return + `ABSENT` instead of falling through. +- **A path element may name an open-struct entry**, so + `getpropertyat(node, :metadata, :labels, "role")` reads a label without a + separate `kuber_props` call. + +Field names are the *generated* ones, which lowercase the JSON name — `:nodename`, +not `:nodeName` (C4). This helper does not fold case: a wrong name reads as +absent, exactly as a wrong name should. + +A vector met by a non-integer path element is mapped over, as on 0.x: +`getpropertyat(podlist, :items, :metadata, :name)` returns a vector of names. + +```julia +Kuber.getpropertyat(pod, :spec, :containers, 1, :image) +Kuber.getpropertyat(pod, :metadata, :labels, "app") +``` +""" +function getpropertyat(obj, path...) + val = _field(obj) + (val === nothing || isempty(path)) && return val + + val = _lookup(val, path[1]) + rest = Base.tail(path) + (isempty(rest) || val === nothing) && return val + + if val isa AbstractVector && !(rest[1] isa Integer) + return [getpropertyat(item, rest...) for item in val] + end + return getpropertyat(val, rest...) +end + +""" + haspropertyat(obj, path...) -struct KApi - api::DataType - types::Module +Whether every step of a path is present — the question +`getpropertyat(obj, path...) !== nothing` answers, without fetching the value. + +The replacement for `OpenAPI.Clients.haspropertyat`; see +[`getpropertyat`](@ref) for why `ABSENT` is the interesting case and why neither +is exported. + +Mapped over a vector met by a non-integer path element, as on 0.x, so the result +is a `Vector{Bool}` there rather than a `Bool`. +""" +function haspropertyat(obj, path...) + val = _field(obj) + val === nothing && return false + isempty(path) && return true + + val = _lookup(val, path[1]) + val === nothing && return false + rest = Base.tail(path) + isempty(rest) && return true + + if val isa AbstractVector && !(rest[1] isa Integer) + return [haspropertyat(item, rest...) for item in val] + end + return haspropertyat(val, rest...) end mutable struct KuberContext - apimodule::Module - client::OpenAPI.Clients.Client - apis::Dict{Symbol,Vector{KApi}} - modelapi::Dict{Symbol,KApi} + server::String + clients::Dict{Module,Runtime.Client} + client_kwargs::NamedTuple + request_options::NamedTuple + apis::Dict{Symbol,Vector{Module}} + modelapi::Dict{Symbol,Module} namespace::String default_retries::Int retry_all_apis::Bool initialized::Bool - httplib::Union{Nothing,Symbol} - - function KuberContext(apimodule::Module=ApiImpl; httplib::Union{Nothing,Symbol}=nothing, kwargs...) - kctx = new(apimodule) - - rtfn = (return_types,response_code,response_data)->kuber_type(kctx, return_types, response_code, response_data) - client_kwargs = _openapi_client_kwargs(httplib) - openapiclient = OpenAPI.Clients.Client(DEFAULT_URI; get_return_type=rtfn, client_kwargs..., kwargs...) - openapiclient.headers["Connection"] = _connection_header_value(httplib) - - kctx.client = openapiclient - kctx.apis = Dict{Symbol,Vector}() - kctx.modelapi = Dict{Symbol,KApi}() - kctx.namespace = DEFAULT_NAMESPACE - kctx.default_retries = 5 - kctx.retry_all_apis = false - kctx.initialized = false - kctx.httplib = httplib - return kctx + + function KuberContext(; kwargs...) + new( + DEFAULT_URI, + Dict{Module,Runtime.Client}(), + NamedTuple(kwargs), + NamedTuple(), + Dict{Symbol,Vector{Module}}(), + Dict{Symbol,Module}(), + DEFAULT_NAMESPACE, + 5, + false, + false, + ) end end @@ -129,42 +207,266 @@ struct KuberWatchContext stream::KuberEventStream end -apimodule(ctx::KuberContext) = ctx.apimodule -apimodule(ctx::KuberWatchContext) = apimodule(ctx.ctx) +_kubectx(ctx::KuberContext) = ctx +_kubectx(ctx::KuberWatchContext) = ctx.ctx + +show(io::IO, ctx::KuberContext) = print(io, "Kubernetes namespace ", ctx.namespace, " at ", ctx.server) + +get_server(ctx::Union{KuberContext,KuberWatchContext}) = _kubectx(ctx).server +get_ns(ctx::Union{KuberContext,KuberWatchContext}) = _kubectx(ctx).namespace + +""" + set_ns(ctx, namespace) + +Set the namespace this context should operate with. +""" +set_ns(ctx::KuberContext, namespace::String) = (ctx.namespace = namespace) + +# ── clients ──────────────────────────────────────────────────────────────── + +""" + client_for(ctx, mod) -> Runtime.Client + +The client for one generated group module, built on first use. + +There is deliberately one client *per module*: a `Runtime.Client` is bound to +its module's compiled `_SPEC`, and sharing one across modules fails ("requested +node is not a compiled schema location"). This mirrors the per-API-struct +`apictx` the old client needed. +""" +client_for(ctx::KuberContext, mod::Module) = get!(() -> _new_client(ctx, mod), ctx.clients, mod) +client_for(ctx::KuberWatchContext, mod::Module) = client_for(ctx.ctx, mod) + +function _new_client(ctx::KuberContext, mod::Module) + client = mod.Client(ctx.server; require_credentials = false, ctx.client_kwargs...) + # cheap and uniform: every client can watch, but only calls that pass + # `accept = WATCH_MEDIA` decode through this codec + Runtime.codec!(client, WATCH_MEDIA; decode = (bytes, _) -> JSON.parse(String(bytes))) + return client +end + +# ── exceptions ───────────────────────────────────────────────────────────── + +""" + KuberException(code, message, status, response) +A failed Kubernetes API call. `status` is the decoded k8s `Status` object when +the server sent one (its `message` and `code` take precedence), and `response` +is the underlying `OpenAPI.Runtime.ApiError` or HTTP response. +""" struct KuberException <: Exception code::Int message::String - status::Union{Nothing,OpenAPI.APIModel} - response::Union{Nothing,OpenAPI.Clients.ApiResponse} + status::Any + response::Any end -function KuberException(response::OpenAPI.Clients.ApiResponse, status::Union{Nothing,OpenAPI.APIModel}) - http_response = response.raw - code = http_response.status +showerror(io::IO, e::KuberException) = print(io, "KuberException(", e.code, "): ", e.message) - # HTTP.Response doesn't have .message field like Downloads.Response - message = hasproperty(http_response, :message) ? http_response.message : "HTTP $code" +""" + KuberException(err::Runtime.ApiError) - # if status is available, use it to override the message and code - if !isnothing(status) - if hasproperty(status, :message) && !isnothing(status.message) && !isempty(status.message) - message = status.message +Rewrap a generated operation's error. The body is parsed here rather than read +off `err.decoded`: k8s error statuses are mostly undocumented in the OpenAPI +document, and for an undocumented status the runtime leaves `decoded` as raw +bytes. +""" +function KuberException(err::Runtime.ApiError) + code = err.status + message = "HTTP $code in $(err.operation_id)" + status = nothing + body = isvalid(String, err.body) ? String(copy(err.body)) : "" + if !isempty(body) + message = body + parsed = try + JSON.parse(body) + catch + nothing end - if hasproperty(status, :code) && !isnothing(status.code) && (status.code != 0) - code = status.code + if parsed isa AbstractDict && get(parsed, "kind", nothing) == "Status" + status = try + kuber_obj(parsed) + catch + parsed + end + m = get(parsed, "message", nothing) + (m isa AbstractString && !isempty(m)) && (message = m) + c = get(parsed, "code", nothing) + (c isa Integer && c != 0) && (code = c) end end + return KuberException(code, message, status, err) +end + +# ── retries ──────────────────────────────────────────────────────────────── + +""" +Delays between attempts, customized by TPS requirement. The default minimum is +2 TPS. + +`max_tries` is the number of **attempts**, so there are `max_tries - 1` delays +between them. It used to be passed straight through as `ExponentialBackOff`'s +`n`, which is a count of *retries* — so `max_tries=1` made two requests, and a +mutating call, which takes `retries(ctx, true) == 1`, was retried once despite +`set_retries`' `all_apis=false` meaning it should not be (G20). +""" +k8s_delay(tps, max_tries = 1) = + ExponentialBackOff(n = max(0, max_tries - 1), first_delay = (1 / tps), factor = 1.75, jitter = 0.1) + +""" +Response codes that can be retried: 500-504 are unexpected server errors, and 0 +is kept for callers that construct a `KuberException` for a failure where no +HTTP status was obtained. +""" +const k8s_retryable_codes = [0, 429, 500, 501, 502, 503, 504] + +"""How long a 429's `Retry-After` may hold a call, however large the header says.""" +const RETRY_AFTER_CAP = 30.0 + +""" + _retry_after(e) -> Float64 + +The `Retry-After` a 429 asked for, in seconds, or `0.0`. + +Scoped to 429 on purpose. A 5xx may carry the header too, but honouring an +arbitrary server-supplied delay on every transient failure changes the timing of +every retry in the client; 429 is the case where the server is deliberately +pacing us and the number means what it says. + +Only the delta-seconds form is read. `Retry-After` may also be an HTTP date, +which Kubernetes does not send — `tryparse` returns `nothing` for one and the +backoff is used instead, which is the safe direction. +""" +function _retry_after(e) + code = e isa KuberException ? e.code : (e isa Runtime.ApiError ? e.status : 0) + code == 429 || return 0.0 + err = e isa KuberException ? e.response : e + err isa Runtime.ApiError || return 0.0 + for (name, value) in err.headers + lowercase(name) == "retry-after" || continue + secs = tryparse(Float64, strip(value)) + secs === nothing && continue + return clamp(secs, 0.0, RETRY_AFTER_CAP) + end + return 0.0 +end + +""" + k8s_retry_cond(s, e, retryable_codes=k8s_retryable_codes) + +Whether a failed call should be retried. Pinned to what +`test/characterize_retries.jl` observes at the OpenAPI commit this branch +targets: + +- `Runtime.ApiError` (any non-2xx) carries `.status`; retry the retryable ones. +- transport failures are HTTP.jl exceptions now — the old + `is_request_interrupted` helper does not exist. HTTP.jl 2.x puts them all + under `HTTP.HTTPError`, so the rule is stated as an exclusion list: retry + every `HTTPError` (and the raw `IOError`/`EOFError` a reset connection can + still surface) except the ones that are decisions rather than accidents. + +A watch that dies mid-stream never reaches this function: the watch call +already returned at the response head, so there is no in-flight call to retry. +Stop vs re-watch is decided in the watch loop by whether the consumer closed +the channel (see `simpleapi.jl`), which is what preserves the semantics of +Kuber #67/#68. +""" +const _DECISIVE_HTTP_ERRORS = Union{ + HTTP.CanceledError, # somebody deliberately cancelled the request + HTTP.StatusError, # a status, already covered by ApiError + HTTP.TooManyRedirectsError, + HTTP.AddressInUseError, + HTTP.RetryDeniedError, +} + +function k8s_retry_cond(s, e, retryable_codes = k8s_retryable_codes) + (e isa Runtime.ApiError) && (return (s, e.status in retryable_codes)) + (e isa KuberException) && (return (s, e.code in retryable_codes)) + (e isa _DECISIVE_HTTP_ERRORS) && (return (s, false)) + (e isa HTTP.HTTPError || e isa Base.IOError || e isa EOFError) && (return (s, true)) + return (s, false) +end - return KuberException(code, message, status, response) +""" + _root_cause(e) -> Exception + +Dig a real failure out of the wrappers concurrency adds around it. +`watch(processor, ctx, …)` runs the watched call and the processor under +`@sync`, so a failure in either reaches the caller as a `CompositeException` of +`TaskFailedException`s rather than as itself. + +A composite carrying more than one exception is left alone: there is no single +cause to report. +""" +_root_cause(e) = e +_root_cause(e::TaskFailedException) = _root_cause(e.task.result) +function _root_cause(e::CompositeException) + length(e.exceptions) == 1 || return e + return _root_cause(e.exceptions[1]) end -function check_api_response(result, response::OpenAPI.Clients.ApiResponse) - if !(200 <= response.status <= 299) - status = isa(result, OpenAPI.APIModel) ? result : nothing - throw(KuberException(response, status)) +""" + is_retryable(e) -> Bool + +Whether a failure is transient — an accident worth retrying rather than an +answer. This is the classification Kuber's own retries use, exposed because +consumers need to make the same judgement about calls they drive themselves. + +It replaces `OpenAPI.Clients.is_request_interrupted`, which does not exist in +OpenAPI.jl 1.0. Transport failures are HTTP.jl exceptions now, so the rule is +stated as an exclusion list (see [`k8s_retry_cond`](@ref)): every `HTTP.HTTPError` +except the ones that are decisions, plus `ApiError`/`KuberException` carrying a +5xx. + +```julia +try + pods = list(ctx, :Pod) +catch e + Kuber.is_retryable(e) || rethrow() + ... +end +``` + +Two things it deliberately does not answer: + +- **`OpenAPI.Clients.is_longpoll_timeout` has no successor.** Watches on this + branch carry no overall deadline (`set_timeout` is not applied to them), so a + watch does not end on one — it ends when the consumer closes the stream, and + that is not an exception at all. +- **A `DecodeError` is not retryable here.** A response that does not match the + schema is spec drift, not a hiccup. The watch pump separately recovers from a + truncated *stream item*, which arrives the same way but means the connection + died mid-frame. + +Exceptions raised inside a task are unwrapped first, so this works on what +`watch` actually throws. +""" +is_retryable(e) = k8s_retry_cond(nothing, _root_cause(e))[2] + +""" + k8s_retry(f; max_tries=1, tps=2) + +Call `f`, retrying transient failures up to `max_tries` **attempts** in total +(so `max_tries=1` calls it once and never retries). The last failure is +rethrown; a failure [`k8s_retry_cond`](@ref) calls decisive is rethrown at once. + +Written as an explicit loop rather than `Base.retry` so a 429's `Retry-After` +can be honoured: `Base.retry` takes its delays from an iterator that never sees +the exception, so the server's own pacing is unreachable from it. The backoff is +still the floor — `Retry-After` only ever lengthens a wait (G19). +""" +function k8s_retry(f; max_tries::Integer = 1, tps = 2) + delays = collect(k8s_delay(tps, max_tries)) + attempt = 1 + while true + try + return f() + catch e + (attempt <= length(delays) && k8s_retry_cond(nothing, e)[2]) || rethrow() + sleep(max(delays[attempt], _retry_after(e))) + attempt += 1 + end end - return result end """ @@ -174,156 +476,163 @@ Args: - ctx: the context to set the options for Keyword Args: -- count: how many times to retry (default 5) +- count: how many **attempts** a retryable call gets in total (default 5, so up + to four retries). This counted retries rather than attempts until G20, which + is why a mutating call — pinned to a count of 1 — used to be retried once - all_apis: whether to retry even mutating APIs e.g. `put!` (default false) + +The count is a budget of requests, not of Kuber-level attempts: HTTP.jl's own +retry layer is off by default on a `KuberContext` so that it means what it says. """ -function set_retries(ctx::KuberContext; count::Int=ctx.default_retries, all_apis::Bool=ctx.retry_all_apis) +function set_retries(ctx::KuberContext; count::Int = ctx.default_retries, all_apis::Bool = ctx.retry_all_apis) ctx.default_retries = count ctx.retry_all_apis = all_apis ctx end -retries(ctx::KuberContext, mutating::Bool=true) = (mutating && !ctx.retry_all_apis) ? 1 : ctx.default_retries -retries(watch::KuberWatchContext, mutating::Bool=true) = retries(watch.ctx, mutating) +retries(ctx::KuberContext, mutating::Bool = true) = (mutating && !ctx.retry_all_apis) ? 1 : ctx.default_retries +retries(watch::KuberWatchContext, mutating::Bool = true) = retries(watch.ctx, mutating) -get_client(ctx::KuberContext) = ctx.client -get_client(ctx::KuberWatchContext) = ctx.ctx.client +# ── request options / timeouts ───────────────────────────────────────────── -get_timeout(ctx::Union{KuberContext,KuberWatchContext}) = get_client(ctx).timeout[] +""" + get_request_options(ctx) -> NamedTuple + +The HTTP.jl options passed with every call made through this context. +""" +get_request_options(ctx::Union{KuberContext,KuberWatchContext}) = _kubectx(ctx).request_options -function set_timeout(ctx::Union{KuberContext,KuberWatchContext}, timeout::Integer) - OpenAPI.Clients.set_timeout(get_client(ctx), timeout) +""" + set_request_options(ctx; kwargs...) + +Merge HTTP.jl request options (`connect_timeout`, `request_timeout`, +`read_idle_timeout`, `sslconfig`, …) into the context's per-call defaults. + +`retry` is set to `false` when the context is built, so that `set_retries` and +`max_tries` are the only thing deciding how many requests a call makes. Pass +`retry=true` here to put HTTP.jl's retry layer back underneath Kuber's — the two +compose multiplicatively, and HTTP.jl's has no notion of which calls are +mutating. +""" +function set_request_options(ctx::Union{KuberContext,KuberWatchContext}; kwargs...) + kubectx = _kubectx(ctx) + kubectx.request_options = merge(kubectx.request_options, NamedTuple(kwargs)) ctx end -function with_timeout(fn, ctx::Union{KuberContext,KuberWatchContext}, timeout::Integer) - old_timeout = get_timeout(ctx) - set_timeout(ctx, timeout) - try - fn(ctx) - finally - set_timeout(ctx, old_timeout) - end -end +""" + get_timeout(ctx) -> Union{Nothing,Real} -# JSON 1.x parses objects to JSON.Object; both OpenAPI's from_json and Kuber's own -# helpers dispatch on the concrete Dict{String,Any}. dicttype forces that on 1.x and -# is a no-op on 0.21 (already the default), so one path serves both. -_parse_json(x) = JSON.parse(x; dicttype=Dict{String,Any}) +The overall per-request deadline in seconds, or `nothing` when none is set. +""" +get_timeout(ctx::Union{KuberContext,KuberWatchContext}) = get(get_request_options(ctx), :request_timeout, nothing) -convert(::Type{Vector{UInt8}}, s::T) where {T<:AbstractString} = collect(codeunits(s)) -convert(::Type{T}, json::String) where {T<:OpenAPI.APIModel} = convert(T, _parse_json(json)) -convert(::Type{Dict{String,Any}}, model::T) where {T<:OpenAPI.APIModel} = _parse_json(JSON.json(model)) +""" + set_timeout(ctx, timeout) -is_json_mime(mime::T) where {T <: AbstractString} = ("*/*" == mime) || occursin(r"(?i)application/json(;.*)?", mime) || occursin(r"(?i)application/(.*)-patch\+json(;.*)?", mime) +Set the overall per-request deadline, in seconds. -kind_to_type(ctx::KuberContext, kind::String, version::Union{String,Nothing}=nothing) = kind_to_type(ctx, Symbol(kind), version) -function kind_to_type(ctx::KuberContext, kind::Symbol, version::Union{String,Nothing}=nothing) - types = (version === nothing) ? (ctx.modelapi[kind]).types : api_typedefs(ctx, version) - getfield(types, kind) -end +This is HTTP.jl 2.x's `request_timeout` option, replacing the 0.2.x client's +mutable `timeout[]`. It is *not* applied to watch calls: a watch has no +meaningful overall deadline, and k8s bounds one with the `timeoutseconds` query +parameter instead. +""" +set_timeout(ctx::Union{KuberContext,KuberWatchContext}, timeout::Real) = + set_request_options(ctx; request_timeout = timeout) + +""" + with_timeout(fn, ctx, timeout) -kuber_type(ctx::KuberContext, d) = kuber_type(ctx, Any, d) -kuber_type(ctx::KuberContext, T, data::String) = kuber_type(ctx, T, _parse_json(data)) -function kuber_type(ctx::KuberContext, return_types::Dict{Regex,Type}, response_code::Union{Nothing,Integer}, response_data::String) - default_type = OpenAPI.Clients.get_api_return_type(return_types, response_code, response_data) +Run `fn(ctx)` with a context-local request deadline, restoring the previous +request options afterwards. +""" +function with_timeout(fn, ctx::Union{KuberContext,KuberWatchContext}, timeout::Real) + kubectx = _kubectx(ctx) + old = kubectx.request_options + set_timeout(ctx, timeout) try - json_resp = _parse_json(response_data) - return kuber_type(ctx, default_type, json_resp) - catch - return default_type + fn(ctx) + finally + kubectx.request_options = old end end -function header(resp::Downloads.Response, name::AbstractString, defaultval::AbstractString) - for (n,v) in resp.headers - (n == name) && (return v) - end - return defaultval -end +""" + _call_options(ctx; watch=false) -function kuber_type(ctx::KuberContext, T, j::Dict{String,Any}) - if haskey(j, "kind") && !isempty(ctx.apis) - kind = j["kind"] - version = haskey(j, "apiVersion") ? j["apiVersion"] : nothing - try - T = kind_to_type(ctx, kind, version) - catch ex - @warn("Type not found.", kind, version) - end - elseif haskey(j, "type") && haskey(j, "object") - return apimodule(ctx).Kubernetes.IoK8sApimachineryPkgApisMetaV1WatchEvent - end - T +The request options for one call. A watch drops `request_timeout` (see +`set_timeout`) but keeps connect and idle timeouts, which do bound a stalled +connection. +""" +function _call_options(ctx::Union{KuberContext,KuberWatchContext}; watch::Bool = false) + # HTTP.jl 2.x retries idempotent requests on a retryable status by default, + # underneath `k8s_retry` — so every Kuber attempt cost several requests, + # `max_tries` bounded none of them, and a mutating call could be retried by + # a layer that has no idea it is mutating. Kuber owns retrying (G20). + # Merged this way round so `set_request_options(ctx; retry=true)` wins, and + # applied here rather than on the context so the client constructor — which + # takes no `retry` — never sees it. + opts = merge((; retry = false), get_request_options(ctx)) + (watch && haskey(opts, :request_timeout)) || return opts + return Base.structdiff(opts, NamedTuple{(:request_timeout,)}) end -# OpenAPI conversions insist that JSONs objects are always `Dict{String,Any}`. -# To ensure that for a user supplied Dict, we serialize that to string and parse it back as json. -kuber_obj(ctx::KuberContext, j::AbstractDict) = kuber_obj(ctx, JSON.json(j)) -kuber_obj(ctx::KuberContext, data::String) = _kuber_obj(ctx, _parse_json(data)) -_kuber_obj(ctx::KuberContext, j::AbstractDict) = convert(kind_to_type(ctx, j["kind"], get(j, "apiVersion", nothing)), j) - -show(io::IO, ctx::KuberContext) = print(io, "Kubernetes namespace ", ctx.namespace, " at ", ctx.client.root) - -get_server(ctx::KuberContext) = ctx.client.root -get_ns(ctx::KuberContext) = ctx.namespace +# ── types and conversions ────────────────────────────────────────────────── """ - set_server(ctx, uri, reset_api_versions=false; max_tries=5, httplib=nothing, kwargs...) + kind_to_type(ctx, kind, apiversion=nothing) -> Type -Set the Kubernetes API server endpoint for a context. +The generated model type for a kind. Without an `apiversion`, the group module +the context resolved for that kind decides — so this follows the server's +preferred version, as it did before. -Args: -- ctx: the context for which to set the API server endpoint -- uri: the API server endpoint uri -- reset_api_versions: whether to probe the server again for API versions supported (false by default) - -Keyword Args: -- max_tries: retries allowed while probing API versions from server -- verbose: Log API versions -- httplib: HTTP library to use (:http or :downloads). If not specified, uses the context's stored httplib setting. -- kwargs: other keyword args to pass on while constructing the client for API server (see OpenAPI.jl - https://github.com/JuliaComputing/OpenAPI.jl#readme) +Note that the meta kinds (`Status`, `DeleteOptions`, `WatchEvent`) exist as a +separate type in *every* group module. Types from two modules are never +identical, so compare kinds rather than types when a response may come from a +group other than the one you asked about. """ -function set_server( - ctx::KuberContext, - uri::String=DEFAULT_URI, - reset_api_versions::Bool=false; - max_tries=retries(ctx, false), - verbose::Bool=false, - debug::Bool=false, - httplib::Union{Nothing,Symbol}=nothing, - kwargs... -) - # Use provided httplib, or fall back to context's stored value - effective_httplib = httplib === nothing ? ctx.httplib : httplib +kind_to_type(ctx::Union{KuberContext,KuberWatchContext}, kind::String, apiversion = nothing) = + kind_to_type(ctx, Symbol(kind), apiversion) +function kind_to_type(ctx::Union{KuberContext,KuberWatchContext}, kind::Symbol, apiversion = nothing) + kubectx = _kubectx(ctx) + if apiversion === nothing + kubectx.initialized || set_api_versions!(kubectx) + mod = get(kubectx.modelapi, kind, nothing) + mod === nothing && throw(KeyError(kind)) + apiversion = MODULE_GVS[mod] + end + return KIND_TYPES[(String(apiversion), String(kind))] +end - rtfn = (return_types,response_code,response_data)->kuber_type(ctx, return_types, response_code, response_data) - client_kwargs = _openapi_client_kwargs(effective_httplib) - ctx.client = OpenAPI.Clients.Client(uri; get_return_type=rtfn, verbose=debug, client_kwargs..., kwargs...) - ctx.client.headers["Connection"] = _connection_header_value(effective_httplib) +""" + kuber_type(json) -> Type - # Update stored httplib if explicitly provided - if httplib !== nothing - ctx.httplib = httplib - end +The model type a JSON payload decodes to, from its `kind` and `apiVersion`. +Replaces the old response-sniffing hook, which is no longer needed: with the +specs patched to be true, buffered responses decode to their documented type. +This remains useful for watch frames and for hand-held payloads. +""" +kuber_type(j::AbstractDict) = KIND_TYPES[(String(get(j, "apiVersion", "v1")), String(j["kind"]))] +kuber_type(ctx::Union{KuberContext,KuberWatchContext}, j) = kuber_type(j) - reset_api_versions && set_api_versions!( - ctx; - max_tries=max_tries, - verbose=verbose - ) - ctx.client -end +""" + kuber_obj(json) -> model +Decode a JSON string or object into the typed model its `kind`/`apiVersion` +names. """ - set_ns(ctx, namespace) +kuber_obj(j::AbstractDict) = Runtime._decode(kuber_type(j), j, false) +kuber_obj(data::AbstractString) = kuber_obj(JSON.parse(data)) +kuber_obj(ctx::Union{KuberContext,KuberWatchContext}, j) = kuber_obj(j) -Set the namespace this context should operate with. +""" + kuber_kind(model) -> String -Args: -- ctx: the context to set the namespace for -- namespace: the namespace to set (String) +The k8s kind of a model, read off the value rather than its type so that it +works for the same kind coming from different group modules. """ -set_ns(ctx::KuberContext, namespace::String) = (ctx.namespace = namespace) +kuber_kind(v) = String(_field(v.kind, "")) + +# ── discovery ────────────────────────────────────────────────────────────── camel(a) = string(uppercase(a[1])) * (a[2:end]) @@ -343,186 +652,169 @@ function api_group(group::String) end """ - api_group_type(ctx, group_ver) - -Get the API implementation type (generated struct implemting the OpenAPI endpoint) -given the full group version specifier. -E.g.: - "apiregistration.k8s.io/v1" => ApiRegistrationV1Api - "karpenter.sh/v1alpha5" => KarpenterShV1alpha5Api -""" -api_group_type(ctx::Union{KuberContext,KuberWatchContext}, group_ver) = api_group_type(ctx, String(group_ver)) -function api_group_type(ctx::Union{KuberContext,KuberWatchContext}, group_ver::String) - # group, ver = occursin('/', group_ver) ? split(group_ver, "/") : ("Core", group_ver) - # group = api_group(group) - # ver = camel(ver) - # getfield(apimodule(ctx), Symbol(group * ver * "Api")) - impl = apimodule(ctx) - Tstr = impl.APIVersionMap[group_ver] - getfield(impl, Symbol(Tstr)) -end + api_module(ctx, apiversion) -> Module +The generated module serving a group version, e.g. `"apps/v1"`. """ - api_typedefs(ctx, group_ver) - -Get the API typedefs module (generated module mapping OpenAPI model types for the versioned endpoint) -given the full group version specifier. -E.g.: - "apiregistration.k8s.io/v1" => Typedefs.ApiRegistrationV1 - "karpenter.sh/v1alpha5" => Typedefs.KarpenterShV1alpha5 -""" -api_typedefs(ctx::Union{KuberContext,KuberWatchContext}, group_ver) = api_typedefs(ctx, String(group_ver)) -function api_typedefs(ctx::Union{KuberContext,KuberWatchContext}, group_ver::String) - impl = apimodule(ctx) - Tstr = replace(impl.APIVersionMap[group_ver], r"Api$" => "") - # group, ver = occursin('/', group_ver) ? split(group_ver, "/") : ("Core", group_ver) - # group = api_group(group) - # ver = camel(ver) - # getfield(getfield(apimodule(ctx), :Typedefs), Symbol(group * ver)) - getfield(getfield(impl, :Typedefs), Symbol(Tstr)) -end +api_module(ctx::Union{KuberContext,KuberWatchContext}, apiversion) = GROUP_MODULES[String(apiversion)] function override_pref(name, server_pref, override) if override !== nothing - for (n,v) in override + for (n, v) in override (n == name) && (return v) end end server_pref end -function fetch_all_apis_versions(ctx::KuberContext; override=nothing, verbose::Bool=false, max_tries=retries(ctx, false)) - apis = ctx.apis - vers, http_resp = k8s_retry(; max_tries=max_tries) do - apimodule(ctx).get_a_p_i_versions(apimodule(ctx).ApisApi(ctx.client)) +""" + _discovery_get(ctx, path) + +The two k8s discovery endpoints are the only calls Kuber makes that are not +generated operations — they were the sole reason the old client needed the +generated `ApisApi`/`CoreApi` wrappers. Plain HTTP.jl is enough, and keeps +discovery independent of which group modules happen to be shipped. +""" +function _discovery_get(ctx::KuberContext, path::String; max_tries::Int = retries(ctx, false)) + url = rstrip(ctx.server, '/') * path + headers = Pair{String,String}[get(ctx.client_kwargs, :headers, ())...] + k8s_retry(; max_tries = max_tries) do + resp = HTTP.get(url, headers; status_exception = false, _call_options(ctx)...) + (200 <= resp.status <= 299) || + throw(KuberException(resp.status, "discovery request to $path failed", nothing, resp)) + JSON.parse(String(resp.body)) end - vers = check_api_response(vers, http_resp) - api_groups = vers.groups - for apigrp in api_groups - name = apigrp.name - pref_vers_type = apigrp.preferredVersion - pref_vers_version = override_pref(name, pref_vers_type.version, override) - pref_vers = string(name, "/", pref_vers_version) - supported = String[] +end - try - apis[Symbol(api_group(name))] = [KApi(api_group_type(ctx, pref_vers), api_typedefs(ctx, pref_vers))] - push!(supported, pref_vers_version) - catch ex - if isa(ex, KeyError) - verbose && @info("unsupported $pref_vers") - continue - else - rethrow() - end +function fetch_core_version(ctx::KuberContext; override = nothing, verbose::Bool = false, max_tries = retries(ctx, false)) + versions = String.(_discovery_get(ctx, "/api"; max_tries = max_tries)["versions"]) + preferred = override_pref("Core", versions[1], override) + supported = String[] + mods = Module[] + for v in unique([preferred; versions]) + mod = get(GROUP_MODULES, v, nothing) + if mod === nothing + verbose && @info("unsupported Core $v") + continue end + mod in mods && continue + push!(mods, mod) + push!(supported, v) + end + isempty(mods) || (ctx.apis[:Core] = mods) + if verbose + @info("Core versions", + on_apiserver = join(versions, ", "), + preferred = preferred, + supported = join(supported, ", "), + ) + end + return ctx.apis +end - for api_vers in apigrp.versions - group_version = api_vers.groupVersion - try - if !isa(group_version, AbstractString) - @error("unexpected missing group version, ignoring") - continue - end - gt = api_group_type(ctx, group_version) - td = api_typedefs(ctx, group_version) - ka = KApi(gt, td) - kalist = apis[Symbol(api_group(name))] - if (ka != kalist[1]) - push!(kalist, ka) - push!(supported, api_vers.version) - end - catch - verbose && @info("unsupported $(group_version)") +function fetch_all_apis_versions(ctx::KuberContext; override = nothing, verbose::Bool = false, max_tries = retries(ctx, false)) + groups = _discovery_get(ctx, "/apis"; max_tries = max_tries)["groups"] + for grp in groups + name = String(grp["name"]) + preferred = override_pref(name, String(grp["preferredVersion"]["version"]), override) + onserver = String[String(v["version"]) for v in grp["versions"]] + supported = String[] + mods = Module[] + for v in unique([preferred; onserver]) + mod = get(GROUP_MODULES, string(name, "/", v), nothing) + if mod === nothing + verbose && @info("unsupported $name/$v") + continue end + mod in mods && continue + push!(mods, mod) + push!(supported, v) end - + isempty(mods) || (ctx.apis[Symbol(api_group(name))] = mods) if verbose @info("$name ($(api_group(name))) versions", - on_apiserver = join(map(x->x.version, apigrp.versions), ", "), - preferred = pref_vers_version, + on_apiserver = join(onserver, ", "), + preferred = preferred, supported = join(supported, ", "), ) end - end - apis + return ctx.apis end -function fetch_core_version(ctx::KuberContext; override=nothing, verbose::Bool=false, max_tries=retries(ctx, false)) - apis = ctx.apis - api_vers, http_resp = k8s_retry(; max_tries=max_tries) do - apimodule(ctx).get_core_a_p_i_versions(apimodule(ctx).CoreApi(ctx.client)) - end - api_vers = check_api_response(api_vers, http_resp) - name = "Core" - supported = String[] - pref_vers = override_pref(name, api_vers.versions[1], override) - - apis[:Core] = [KApi(getfield(apimodule(ctx), Symbol(string("Core", camel(pref_vers), "Api"))), getfield(getfield(apimodule(ctx), :Typedefs), Symbol(string("Core", camel(pref_vers)))))] - push!(supported, pref_vers) - - for api_vers in api_vers.versions - try - gt = getfield(apimodule(ctx), Symbol(string("Core", camel(api_vers), "Api"))) - td = getfield(getfield(apimodule(ctx), :Typedefs), Symbol(string("Core", camel(api_vers)))) - ka = KApi(gt, td) - kalist = apis[:Core] - if (ka != kalist[1]) - push!(kalist, ka) - push!(supported, api_vers) - end - catch - @info("unsupported Core $api_vers") - end - end +""" + build_model_api_map(ctx) - if verbose - @info("Core versions", - on_apiserver = join(api_vers.versions, ", "), - preferred = pref_vers, - supported = join(supported, ", "), - ) - end +Map each addressable kind to the group module that serves it, for the +symbol-based simple API. - return apis -end +Kinds come from `KIND_TYPES`, not from a `names()` scan of the module: the old +scan pulled in every model type including ones that are not addressable +resources, while `x-kubernetes-group-version-kind` gives exactly the kinds the +API server will answer for. +Core is registered first and earlier registrations win, so the meta kinds that +every group redefines (`Status`, `WatchEvent`, `DeleteOptions`) resolve to core +deterministically rather than by dictionary order. +""" function build_model_api_map(ctx::KuberContext) - #@info("building model - api map...") modelapi = ctx.modelapi - for (apigroup,apivers) in ctx.apis - apiver = apivers[1] - types = apiver.types - #@info("building model for $apiver") - - for name in names(types; all=true) - (name in [:eval, Symbol("#eval"), :include, Symbol("#include"), Symbol(split(string(types), '.')[end])]) && continue - # de-prioritize extensions for the default simpleapi mapping (so if a model already has a dedicated api version, do not use extensions) - # extensions are deprecated and not supported in k8s versions after v1.16 - # haskey(modelapi, name) && (types === apimodule(ctx).Typedefs.ExtensionsV1beta1) && continue - modelapi[name] = apiver + groups = [:Core; sort!(filter(!=(:Core), collect(keys(ctx.apis))))] + for group in groups + haskey(ctx.apis, group) || continue + mod = ctx.apis[group][1] # the preferred version + gv = MODULE_GVS[mod] + for (apiversion, kind) in keys(KIND_TYPES) + apiversion == gv || continue + get!(modelapi, Symbol(kind), mod) end end - modelapi + return modelapi end -function set_api_versions!(ctx::KuberContext; override=nothing, verbose::Bool=false, max_tries=retries(ctx, false)) +function set_api_versions!(ctx::KuberContext; override = nothing, verbose::Bool = false, max_tries = retries(ctx, false)) ctx.initialized = false empty!(ctx.apis) empty!(ctx.modelapi) - # fetch apis and map the types - fetch_core_version(ctx; override=override, verbose=verbose, max_tries=max_tries) - fetch_all_apis_versions(ctx; override=override, verbose=verbose, max_tries=max_tries) + fetch_core_version(ctx; override = override, verbose = verbose, max_tries = max_tries) + fetch_all_apis_versions(ctx; override = override, verbose = verbose, max_tries = max_tries) build_model_api_map(ctx) - # add custom models - ctx.modelapi[:PodLog] = ctx.modelapi[:Pod] + # pod logs are addressed as their own kind but served by the core module + haskey(ctx.modelapi, :Pod) && (ctx.modelapi[:PodLog] = ctx.modelapi[:Pod]) ctx.initialized = true nothing end -# Add validations for the k8s spec specific int-or-string format -OpenAPI.val_format(val::Union{AbstractString,Integer}, ::Val{Symbol("int-or-string")}) = true -OpenAPI.val_format(val, ::Val{Symbol("int-or-string")}) = false +""" + set_server(ctx, uri, reset_api_versions=false; max_tries=5, verbose=false, kwargs...) + +Set the Kubernetes API server endpoint for a context. + +Args: +- ctx: the context for which to set the API server endpoint +- uri: the API server endpoint uri +- reset_api_versions: whether to probe the server again for API versions supported (false by default) + +Keyword Args: +- max_tries: retries allowed while probing API versions from server +- verbose: Log API versions +- kwargs: defaults for every generated client this context builds — `headers` + (e.g. a bearer token), `request_options` (HTTP.jl options, including TLS + configuration), `validate_requests`, … +""" +function set_server( + ctx::KuberContext, + uri::String = DEFAULT_URI, + reset_api_versions::Bool = false; + max_tries = retries(ctx, false), + verbose::Bool = false, + kwargs... +) + ctx.server = uri + isempty(kwargs) || (ctx.client_kwargs = merge(ctx.client_kwargs, NamedTuple(kwargs))) + empty!(ctx.clients) # clients are bound to the server they were built with + reset_api_versions && set_api_versions!(ctx; max_tries = max_tries, verbose = verbose) + ctx.server +end diff --git a/src/register.jl b/src/register.jl new file mode 100644 index 00000000..f677fd27 --- /dev/null +++ b/src/register.jl @@ -0,0 +1,262 @@ +# Merging out-of-tree generated layers into the registry. +# +# The registry tables are `const` *bindings* to *mutable* `Dict`s, and every key +# carries either the group version or the group module, so a generated layer +# Kuber does not ship can be merged into them without touching, or recompiling, +# anything that is already there. This is what replaces the 0.2.x +# `KuberContext(apimodule)` plug point — registration is process-global, but +# resolution stays per-context: `ctx.apis` and `ctx.modelapi` are still built at +# discovery from whatever the server actually serves. + +using .ApiImpl: GROUP_MODULES, MODULE_GVS, KIND_TYPES, OPS, OP_PARAMS, OP_BODIES + +"""The table names a registry module has to define, in `register!`'s argument order.""" +const REGISTRY_TABLES = (:GROUP_MODULES, :MODULE_GVS, :KIND_TYPES, :OPS, :OP_PARAMS, :OP_BODIES) + +const _VERBS = (:get, :list, :create, :replace, :patch, :delete, :deletecollection) +const _SCOPES = (:namespaced, :cluster, :allns) + +""" +The group modules Kuber itself ships, frozen at precompilation. `unregister!` +refuses to touch these: removing one would leave the shipped tables describing +operations no longer reachable. +""" +const BUILTIN_MODULES = Set{Module}(keys(MODULE_GVS)) + +_empty_bodies() = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}() + +""" + Kuber.register!(source::Module) -> Vector{Module} + Kuber.register!(; group_modules, module_gvs, kind_types, ops, op_params, op_bodies) -> Vector{Module} + +Add generated API group modules that Kuber does not ship — aggregated APIs like +`metrics.k8s.io`, CRD-backed groups, anything captured from a specific cluster — +so that the verb API addresses their kinds like any other. + +`source` is a *registry module*: a module defining the six tables below, in the +shape `gen/openapi_v1/emit_registry.jl` emits. Returns the group modules added, +which is what [`unregister!`](@ref) undoes. + +| table | type | meaning | +|:--|:--|:--| +| `GROUP_MODULES` | `Dict{String,Module}` | apiVersion → the group module serving it | +| `MODULE_GVS` | `Dict{Module,String}` | the exact inverse | +| `KIND_TYPES` | `Dict{Tuple{String,String},Type}` | (apiVersion, kind) → model type | +| `OPS` | `Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}` | (module, verb, kind, scope) → operation | +| `OP_PARAMS` | `Dict{…,Vector{Symbol}}` | positional argument names, path order, `:body` last | +| `OP_BODIES` | `Dict{…,Dict{String,Type}}` | request media type → body type, for operations with a required body | + +`verb` is one of `$(join(_VERBS, ", "))` and `scope` one of `$(join(_SCOPES, ", "))`. + +# Call it from `__init__` + +Registration mutates Kuber's state, and mutations to another module's state do +not survive precompilation. A registering package must therefore call this from +its `__init__`, not at top level: + +```julia +module JuliaHubK8sApi +include("registry.jl") # defines the six tables +__init__() = Kuber.register!(@__MODULE__) +end +``` + +The cost of that is compilation: registered kinds are absent from Kuber's +precompile image, so their first call compiles from scratch. + +# What it refuses + +Everything is validated before anything is merged, so a rejected registration +leaves the tables exactly as they were. A group version already served by a +*different* module is an error rather than a silent override — `unregister!` it +first if replacing it is really the intent. Re-registering identical content is +a no-op, so a package loaded twice in one session is harmless. + +# Which module serves a kind + +Registration order does not decide that. `build_model_api_map` fills +`ctx.modelapi` at discovery, first-wins, with core first and the remaining groups +in alphabetical order — so if two groups declare the same kind name, which one an +unqualified `get(ctx, :Thing)` reaches is decided by that ordering. Pass +`apiversion=` to be explicit. + +A context that has already run discovery will not see newly registered kinds in +`ctx.modelapi` until it does so again ([`set_api_versions!`](@ref)); addressing +them by `apiversion=` works immediately, since that path reads the tables +directly. +""" +function register!(source::Module) + absent = Symbol[t for t in REGISTRY_TABLES if !isdefined(source, t)] + isempty(absent) && return register!(; + group_modules = getproperty(source, :GROUP_MODULES), + module_gvs = getproperty(source, :MODULE_GVS), + kind_types = getproperty(source, :KIND_TYPES), + ops = getproperty(source, :OPS), + op_params = getproperty(source, :OP_PARAMS), + op_bodies = getproperty(source, :OP_BODIES), + ) + throw(ArgumentError( + "$(nameof(source)) is not a registry module: it does not define " * + join(absent, ", ") * ". A registry module defines all of " * + join(REGISTRY_TABLES, ", ") * " — see Kuber.register!")) +end + +function register!(; + group_modules::AbstractDict, + module_gvs::AbstractDict, + kind_types::AbstractDict, + ops::AbstractDict, + op_params::AbstractDict, + op_bodies::AbstractDict = _empty_bodies(), +) + _check_registration(group_modules, module_gvs, kind_types, ops, op_params, op_bodies) + + merge!(GROUP_MODULES, group_modules) + merge!(MODULE_GVS, module_gvs) + merge!(KIND_TYPES, kind_types) + merge!(OPS, ops) + merge!(OP_PARAMS, op_params) + merge!(OP_BODIES, op_bodies) + + return Module[group_modules[gv] for gv in sort!(collect(keys(group_modules)))] +end + +""" + _check_registration(tables...) + +Reject a registration before any of it is merged. Two kinds of check: that the +incoming tables satisfy the invariants `test/registry.jl` asserts over the merged +result, and that they do not contradict what is already registered. +""" +function _check_registration(group_modules, module_gvs, kind_types, ops, op_params, op_bodies) + # ── internally consistent ────────────────────────────────────────────── + length(group_modules) == length(module_gvs) || throw(ArgumentError( + "GROUP_MODULES has $(length(group_modules)) entries and MODULE_GVS $(length(module_gvs)); they must be inverses")) + for (gv, mod) in group_modules + mod isa Module || throw(ArgumentError("GROUP_MODULES[$gv] is a $(typeof(mod)), not a Module")) + get(module_gvs, mod, nothing) == gv || throw(ArgumentError( + "MODULE_GVS is not the inverse of GROUP_MODULES: no $(nameof(mod)) => \"$gv\" entry")) + # the one thing Kuber calls on a group module by name + isdefined(mod, :Client) || throw(ArgumentError( + "$(nameof(mod)) defines no `Client`, so Kuber cannot build a client for $gv")) + end + + for ((gv, kind), T) in kind_types + haskey(group_modules, gv) || throw(ArgumentError( + "KIND_TYPES entry (\"$gv\", \"$kind\") names a group version that is not being registered")) + T isa Type || throw(ArgumentError("KIND_TYPES[(\"$gv\", \"$kind\")] is a $(typeof(T)), not a Type")) + parentmodule(T) === group_modules[gv] || throw(ArgumentError( + "KIND_TYPES[(\"$gv\", \"$kind\")] is $T, which is not defined in $(nameof(group_modules[gv]))")) + end + + keys(ops) == keys(op_params) || throw(ArgumentError( + "OPS and OP_PARAMS must cover the same keys; every operation needs its positional argument names")) + for (key, f) in ops + mod, verb, kind, scope = key + haskey(module_gvs, mod) || throw(ArgumentError( + "OPS key $key names $(nameof(mod)), which is not being registered")) + f isa Function || throw(ArgumentError("OPS[$key] is a $(typeof(f)), not a Function")) + parentmodule(f) === mod || throw(ArgumentError( + "OPS[$key] is defined in $(nameof(parentmodule(f))), not in $(nameof(mod))")) + verb in _VERBS || throw(ArgumentError("OPS key $key has verb :$verb, expected one of $_VERBS")) + scope in _SCOPES || throw(ArgumentError("OPS key $key has scope :$scope, expected one of $_SCOPES")) + # watching is `watch=true` on the list operation plus an accept-scoped + # codec; the deprecated /watch/ paths are deliberately not carried + startswith(String(nameof(f)), "watch") && throw(ArgumentError( + "OPS[$key] is $(nameof(f)): the deprecated /watch/ operations are not used, " * + "watching goes through the list operation")) + end + + # `_positional` consumes OP_PARAMS positionally, so a mis-emitted table + # would be accepted here and fail confusingly at call time instead + for (key, params) in op_params + _, verb, _, scope = key + allunique(params) || throw(ArgumentError("OP_PARAMS[$key] repeats an argument: $params")) + if scope === :namespaced + (!isempty(params) && first(params) === :namespace) || throw(ArgumentError( + "OP_PARAMS[$key] is namespaced, so :namespace must come first, got $params")) + else + :namespace in params && throw(ArgumentError( + "OP_PARAMS[$key] is $scope-scoped but takes a :namespace")) + end + if :body in params + last(params) === :body || throw(ArgumentError( + "OP_PARAMS[$key] must take :body last, got $params")) + verb in (:create, :replace, :patch) || throw(ArgumentError( + "OP_PARAMS[$key] takes a :body, which :$verb does not send")) + end + end + for (key, media) in op_bodies + haskey(ops, key) || throw(ArgumentError("OP_BODIES has an entry for $key with no matching OPS entry")) + media isa AbstractDict && !isempty(media) || throw(ArgumentError( + "OP_BODIES[$key] must map at least one media type to a body type, got $(typeof(media))")) + for (m, T) in media + T isa Type || throw(ArgumentError("OP_BODIES[$key][$m] is a $(typeof(T)), not a Type")) + end + end + + # ── does not contradict what is already registered ───────────────────── + for (gv, mod) in group_modules + held = get(GROUP_MODULES, gv, nothing) + (held === nothing || held === mod) || throw(ArgumentError( + "$gv is already served by $(nameof(held)); unregister it before registering $(nameof(mod))")) + held_gv = get(MODULE_GVS, mod, nothing) + (held_gv === nothing || held_gv == gv) || throw(ArgumentError( + "$(nameof(mod)) is already registered for $held_gv and cannot also serve $gv")) + end + for (key, T) in kind_types + held = get(KIND_TYPES, key, nothing) + (held === nothing || held === T) || throw(ArgumentError( + "kind \"$(key[2])\" in $(key[1]) is already registered as $held")) + end + for (key, f) in ops + held = get(OPS, key, nothing) + (held === nothing || held === f) || throw(ArgumentError( + "$key is already registered as $(nameof(held))")) + end + return nothing +end + +""" + Kuber.unregister!(mods::Module...) -> Vector{Module} + +Remove group modules added by [`register!`](@ref), along with every kind and +operation they brought. Accepts either the group modules themselves — what +`register!` returns — or the registry module that registered them. + +Lenient by design, so it is safe in a `finally`: a module that is not registered +is skipped, and the return value is what was actually removed. The group modules +Kuber itself ships cannot be removed. + +Contexts keep resolving the removed kinds until they run discovery again, since +`ctx.modelapi` is a snapshot; `ctx.clients` holds a client per module and is +likewise only cleared by `set_server`. +""" +function unregister!(mods::Module...) + targets = Module[] + for mod in mods + if haskey(MODULE_GVS, mod) + push!(targets, mod) + elseif isdefined(mod, :GROUP_MODULES) + append!(targets, values(getproperty(mod, :GROUP_MODULES))) + end + end + for mod in targets + mod in BUILTIN_MODULES && throw(ArgumentError( + "$(nameof(mod)) is part of Kuber's own generated layer and cannot be unregistered")) + end + + removed = Module[] + for mod in unique(targets) + gv = get(MODULE_GVS, mod, nothing) + gv === nothing && continue + filter!(p -> p.first[1] != gv, KIND_TYPES) + filter!(p -> p.first[1] !== mod, OPS) + filter!(p -> p.first[1] !== mod, OP_PARAMS) + filter!(p -> p.first[1] !== mod, OP_BODIES) + delete!(GROUP_MODULES, gv) + delete!(MODULE_GVS, mod) + push!(removed, mod) + end + return removed +end diff --git a/src/simpleapi.jl b/src/simpleapi.jl index 37f9d141..013cd2ce 100644 --- a/src/simpleapi.jl +++ b/src/simpleapi.jl @@ -1,4 +1,6 @@ -# simple Julia APIs over Kubernetes OpenAPI interface +# simple Julia APIs over the generated Kubernetes clients + +using .ApiImpl: OP_BODIES function sel(label::String, op::Symbol) @assert op === :exists @@ -7,31 +9,159 @@ end sel(label::String, op::Symbol, items::String...) = label * " " * string(op) * " (" * join(items, ",") * ")" sel(cnd::String...) = join(cnd, ", ") -_kubectx(ctx::KuberContext) = ctx -_kubectx(ctx::KuberWatchContext) = ctx.ctx +# ── resolution ───────────────────────────────────────────────────────────── -function _get_apictx(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, apiversion::Union{String,Nothing}; max_tries::Int=retries(ctx, false)) - kubectx = _kubectx(ctx) - kubectx.initialized || set_api_versions!(kubectx; max_tries=max_tries) +""" + _resolve_module(ctx, O, apiversion) -> Module +The generated group module serving kind `O`: the one for `apiversion` when +given, else whichever the context discovered for that kind (the server's +preferred version). +""" +function _resolve_module(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, + apiversion::Union{String,Nothing}; max_tries::Int = retries(ctx, false)) + kubectx = _kubectx(ctx) + kubectx.initialized || set_api_versions!(kubectx; max_tries = max_tries) if apiversion !== nothing - k = Kuber.api_group_type(ctx, apiversion) - apictx = k(kubectx.client) - else - kapi = kubectx.modelapi[O] - apictx = kapi.api(kubectx.client) + mod = get(GROUP_MODULES, apiversion, nothing) + mod === nothing && throw(ArgumentError( + "no API module is registered for $apiversion (out-of-tree groups plug in through Kuber.register!)")) + return mod + end + mod = get(kubectx.modelapi, O, nothing) + mod === nothing && throw(ArgumentError("no API group on this server serves $O")) + return mod +end + +""" + _scopes(namespace) -> Tuple{Symbol,...} + +Which operation scopes to try, in order, for a requested namespace. `ctx.namespace` +defaults to `"default"`, so cluster-scoped kinds (`Namespace`, `Node`, +`PersistentVolume`, …) come through here looking namespaced and must fall back +to `:cluster` — the same fallback chain the old code got from `isdefined` +probing, now a table lookup. +""" +function _scopes(namespace::Union{String,Nothing}) + (namespace === nothing || isempty(namespace)) && return (:cluster, :allns) + namespace == "*" && return (:allns, :cluster) + return (:namespaced, :cluster, :allns) +end + +""" + _find_op(mod, verb, O, namespace) -> (key, function, params, scope) + +The registry entry for a verb on a kind, or an error naming what was missing. +""" +function _find_op(mod::Module, verb::Symbol, O::Symbol, namespace::Union{String,Nothing}) + for scope in _scopes(namespace) + key = (mod, verb, O, scope) + haskey(OPS, key) && return (key, OPS[key], OP_PARAMS[key], scope) + end + throw(ArgumentError("$(nameof(mod)) has no $verb operation for $O")) +end + +""" + _positional(params, namespace, name, body) -> Vector{Any} + +Fill a generated operation's positional arguments. The order comes from the +spec (`OP_PARAMS`): path parameters in path order, so the namespace comes +*first*, then the name, then a required body last. +""" +function _positional(params::Vector{Symbol}, namespace, name, body) + args = Any[] + named = count(p -> p !== :namespace && p !== :body, params) + named <= 1 || throw(ArgumentError( + "operations with more than one non-namespace path parameter are not addressable " * + "through the verb API: $params")) + for p in params + if p === :namespace + namespace === nothing && throw(ArgumentError("a namespace is required for this operation")) + push!(args, String(namespace)) + elseif p === :body + body === nothing && throw(ArgumentError("a request body is required for this operation")) + push!(args, body) + else + # `:name` for everything the apiserver serves, but a captured group + # can name it something else, so the name argument fills whichever + # single one it is. A group needing *more* than one is out of reach + # of this API and says so above — `custom.metrics.k8s.io` is the + # known case, addressing metrics through `{resource}/{name}/{subresource}` + # (see `OpenAPIv1ConsumerGaps.md` C5 and the reference capture). + name === nothing && throw(ArgumentError("a $p is required for this operation")) + push!(args, String(name)) + end + end + return args +end + +""" + _takes_name(params) -> Bool + +Whether an operation has a path parameter the `name` argument can fill. +""" +_takes_name(params::Vector{Symbol}) = any(p -> p !== :namespace && p !== :body, params) + +""" + _op_kwargs(kwargs) -> NamedTuple + +Translate Kuber's snake_case keyword arguments to the generated lowercase ones +(`label_selector` -> `labelselector`, `resource_version` -> `resourceversion`) +and drop `nothing` values: generated optional parameters are +`Union{Absent,T}`, so an explicit `nothing` would fail request validation +instead of being omitted. +""" +function _op_kwargs(kwargs) + translated = Pair{Symbol,Any}[] + for (k, v) in pairs(kwargs) # pairs(), so a NamedTuple works too + v === nothing && continue + push!(translated, Symbol(lowercase(replace(String(k), "_" => ""))) => v) + end + return (; translated...) +end + +""" + _call(f, args...; kwargs...) + +Invoke a generated operation, rewrapping its `ApiError` as a `KuberException` +so callers (and `k8s_retry_cond`) see Kuber's exception type. Operations return +the decoded value or throw; there are no `(result, response)` tuples and no +`check_api_response` any more. +""" +function _call(f, args...; kwargs...) + try + return f(args...; kwargs...) + catch e + e isa Runtime.ApiError && throw(KuberException(e)) + rethrow() end - apictx end -_api_function(ctx::Union{KuberContext,KuberWatchContext}, name::Symbol) = isdefined(apimodule(ctx), name) ? apimodule(ctx).eval(name) : nothing -_api_function(ctx::Union{KuberContext,KuberWatchContext}, name) = _api_function(ctx, Symbol(name)) +# ── watch plumbing ───────────────────────────────────────────────────────── + +""" + watch(fn, ctx; buffersize=1024, stream=KuberEventStream(buffersize)) -function watch(fn::Function, ctx::KuberContext; buffersize::Int=1024, stream::KuberEventStream=KuberEventStream(buffersize)) +Run `fn(watchctx, stream)` with a watch-capable context. +""" +function watch(fn::Function, ctx::KuberContext; buffersize::Int = 1024, + stream::KuberEventStream = KuberEventStream(buffersize)) watchctx = KuberWatchContext(ctx, stream) fn(watchctx, stream) end +""" + watch(streamprocessor, ctx, watched, args...; kwargs...) + +Run a watched call and a stream processor concurrently, ending when either +does. + +`watched` (normally `list` or `get`) stays long-lived: its watch branch pumps +the stream inline and only returns when the watch is finished, so the `finally +close(stream)` blocks below remain the end-of-watch signal they were under the +0.2.x client — even though the underlying generated call now returns as soon as +the response head arrives. +""" function watch(streamprocessor::Function, ctx::KuberContext, watched::Function, args...; kwargs...) watch(ctx) do watchctx, stream @sync begin @@ -44,9 +174,9 @@ function watch(streamprocessor::Function, ctx::KuberContext, watched::Function, streamprocessor(stream) finally # Symmetric to the watcher task above: if the stream processor - # dies (e.g. an exception while converting an event), close the - # stream so the HTTP watch task aborts too. Otherwise `@sync` - # silently waits for the connection to end while events pile up + # dies (e.g. an exception while handling an event), close the + # stream so the watch aborts too. Otherwise `@sync` silently + # waits for the connection to end while events pile up # unconsumed — a deaf watch with no error surfaced. close(stream) end @@ -54,360 +184,550 @@ function watch(streamprocessor::Function, ctx::KuberContext, watched::Function, end end -function list(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, name::String; - apiversion::Union{String,Nothing}=nothing, - namespace::Union{String,Nothing}=_kubectx(ctx).namespace, - max_tries::Int=retries(ctx, false), - watch=isa(ctx, KuberWatchContext), - resource_version=nothing, - kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") +""" + watch(ctx, O, outstream; kwargs...) - eventstream = isa(ctx, KuberWatchContext) ? ctx.stream : nothing - result = nothing - args = Any[name] - _O_ = to_snake_case(string(O)) - if allnamespaces - apicall = apimodule(ctx).eval(Symbol("list_$(_O_)_for_all_namespaces")) - elseif namespaced - apicall = apimodule(ctx).eval(Symbol("list_namespaced_$(_O_)")) - push!(args, namespace) - else - apicall = apimodule(ctx).eval(Symbol("list_$(_O_)")) - end +Stream watch events for kind `O` onto `outstream`. Unlike the `watch(fn, ...)` +form this emits only events, with no initial list result. - if !watch || resource_version === nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, args...; kwargs...)...) - end +That also means no resync frame after an expired `resourceVersion` (see +[`list`](@ref)): the watch recovers, but the consumer is not told what it missed +while it was gone. A consumer maintaining a cache wants the list frames — use +`watch(fn, ctx)` and drive `list` yourself. +""" +function watch(ctx::KuberContext, O::Symbol, outstream::Channel; kwargs...) + list(KuberWatchContext(ctx, outstream), O; watch = true, push_initial = false, kwargs...) +end + +""" + _resource_version(object) -> Union{String,Nothing} + +`metadata.resourceVersion` of a typed model or a raw JSON object. The generated +field is lowercase (`resourceversion`) and may be `ABSENT`. +""" +function _resource_version(object) + if object isa AbstractDict + metadata = get(object, "metadata", nothing) + metadata isa AbstractDict || return nothing + rv = get(metadata, "resourceVersion", nothing) + return rv isa AbstractString ? String(rv) : nothing end + hasproperty(object, :metadata) || return nothing + metadata = _field(object.metadata) + (metadata === nothing || !hasproperty(metadata, :resourceversion)) && return nothing + rv = _field(metadata.resourceversion) + return rv isa AbstractString ? String(rv) : nothing +end - # if not watching, return the first result - watch || (return result) - if result !== nothing - resource_version = result.metadata.resourceVersion - # push the first Event consisting of existing data - if isnothing(eventstream) - throw(ArgumentError("Event stream not provided in watch mode")) - else - put!(eventstream, result) +""" + _status_code(object) -> Union{Int,Nothing} + +`code` of a k8s `Status`, typed or raw. +""" +function _status_code(object) + raw = object isa AbstractDict ? get(object, "code", nothing) : + (hasproperty(object, :code) ? _field(object.code) : nothing) + return raw isa Integer ? Int(raw) : nothing +end + +""" + _to_event(item) -> KuberEvent + +Second-stage decode of one raw watch frame. The codec hands over +`{"type": ..., "object": ...}` as JSON; the object is decoded to its typed +model via `KIND_TYPES`, and left as the raw JSON when the kind belongs to a +group this build does not ship. +""" +function _to_event(item) + item isa AbstractDict || return KuberEvent("ERROR", item) + type = String(get(item, "type", "ERROR")) + object = get(item, "object", nothing) + if object isa AbstractDict && haskey(object, "kind") + object = try + kuber_obj(object) + catch + object end end + return KuberEvent(type, object) +end - # start watch and return the HTTP response object on completion - result = k8s_retry(; max_tries=max_tries, stream=eventstream) do - check_api_response(apicall(apictx, eventstream, args...; watch=watch, resource_version=resource_version, kwargs...)...) - end +""" + _resync(ctx, client, op, args, callkwargs; max_tries, push_initial) -> (rv, stopped) - return result -end +Recover from an expired `resourceVersion` by listing again, and deliver that +list to the consumer as a resync frame. -function list(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol; - apiversion::Union{String,Nothing}=nothing, - namespace::Union{String,Nothing}=_kubectx(ctx).namespace, - max_tries::Int=retries(ctx, false), - watch=isa(ctx, KuberWatchContext), - resource_version=nothing, - kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") +Watching from no `resourceVersion` at all would be simpler, and is what this did +first, but it is wrong for anything maintaining a cache: k8s replays current +state as synthetic `ADDED` events, so a consumer hears about everything that +still exists and never hears about what was **deleted while the watch was gone**. +Those entries would survive in its store for the lifetime of the process. - eventstream = isa(ctx, KuberWatchContext) ? ctx.stream : nothing +Listing instead gets complete state in one object plus a `resourceVersion` to +resume from, with no replay — the same answer client-go's reflector gives. The +list is pushed onto the stream exactly as the initial one was, which is what +makes the contract a single rule: *a list object means complete current state, +so discard anything cached that is not in it.* - result = nothing - args = Any[] - _O_ = to_snake_case(string(O)) - if allnamespaces - apicall = apimodule(ctx).eval(Symbol("list_$(_O_)_for_all_namespaces")) - elseif namespaced - apicall = apimodule(ctx).eval(Symbol("list_namespaced_$(_O_)")) - push!(args, namespace) - else - apicall = apimodule(ctx).eval(Symbol("list_$(_O_)")) - end +`push_initial=false` says the consumer wants events only, and is honoured here +too: it still gets the recovery, but not the state, and has to track expiry +itself. - if !watch || resource_version === nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, args...; kwargs...)...) +Returns the fresh `resourceVersion` and whether the consumer stopped the watch +while this was happening. +""" +function _resync(ctx::KuberWatchContext, client, op::Function, args::Vector, + callkwargs::NamedTuple; max_tries::Int, push_initial::Bool) + result = k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, request_options = _call_options(ctx), callkwargs...) + end + if push_initial + try + put!(ctx.stream, result) + catch e + e isa InvalidStateException || rethrow() + return (nothing, true) # the consumer closed the stream end end + return (_resource_version(result), false) +end - # if not watching, retuen the first result - watch || (return result) - if result !== nothing - resource_version = result.metadata.resourceVersion - # push the first Event consisting of existing data - if isnothing(eventstream) - throw(ArgumentError("Event stream not provided in watch mode")) +""" + _pump_watch(ctx, mod, op, params, namespace, name, callkwargs, rv; max_tries, buffersize) + +Stream watch events onto `ctx.stream` until the consumer stops the watch, +re-establishing the connection as needed. Returns when the watch is over. + +The retry semantics here are dictated by what the runtime actually does (see +`test/characterize_retries.jl`): + +- the generated call returns at the response head, so a *failure to establish* + is what `k8s_retry` wraps; a failure mid-stream arrives on the raw channel +- a mid-stream drop on an item boundary closes the raw channel cleanly, exactly + like a watch ending normally on `timeoutseconds`. So a clean close cannot mean + "stop", and the watch is re-established from the last `resourceVersion` seen — + which is what Kuber #68 asks for +- the consumer closing the public stream is therefore the *only* stop signal + (Kuber #67/#68): it makes `put!` throw and `isopen` false +- a truncated item closes the raw channel with a `DecodeError`, and a connection + aborted mid-chunk with an HTTP.jl error; re-establish for both +- `410 Gone` is not an `ApiError`: k8s answers an expired `resourceVersion` with + an in-stream `ERROR` event. The answer is to **list again** and watch from the + fresh `resourceVersion`, delivering that list as a resync frame — see + `_resync`, and the "watching" section of the README for what a consumer owes + it +""" +function _pump_watch(ctx::KuberWatchContext, mod::Module, op::Function, params::Vector{Symbol}, + namespace, name, callkwargs::NamedTuple, rv::Union{String,Nothing}; + max_tries::Int, buffersize::Int, push_initial::Bool = true) + eventstream = ctx.stream + client = client_for(ctx, mod) + options = _call_options(ctx; watch = true) + args = _positional(params, namespace, name, nothing) + + idle_restarts = 0 + while isopen(eventstream) + raw = KuberEventStream(buffersize) + rvkwargs = rv === nothing ? NamedTuple() : (; resourceversion = rv) + try + k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, watch = true, accept = WATCH_MEDIA, stream_to = raw, + request_options = options, rvkwargs..., callkwargs...) + end + catch + close(raw) + rethrow() + end + + # Abort the transfer promptly when the consumer stops the watch. The pump + # below blocks waiting for the next frame, which on a quiet resource can + # be a long time — long enough that noticing the stop only on the next + # frame would leave `watch()` hanging, and would keep the `@sync` in + # `watch(streamprocessor, ...)` alive after the processor died, which is + # the deaf watch Kuber #67 fixed. + stopwatcher = @async begin + while isopen(eventstream) && isopen(raw) + sleep(0.25) + end + isopen(raw) && close(raw) + end + + expired = false + delivered = 0 + try + for item in raw + event = _to_event(item) + if event.type == "ERROR" && _status_code(event.object) == 410 + expired = true + break + end + put!(eventstream, event) + delivered += 1 + seen = _resource_version(event.object) + seen === nothing || (rv = seen) + end + catch e + # the consumer closing the public stream is a stop, not a failure + (isopen(eventstream) && !(e isa InvalidStateException)) || return nothing + # Otherwise the stream died under us. A truncated item surfaces as a + # DecodeError; a connection aborted mid-chunk surfaces as an HTTP.jl + # error (`HTTP.ParseError: unexpected EOF while reading HTTP/1 data`), + # which is the same failure `k8s_retry_cond` would retry on a + # buffered call — so recover from both rather than killing the watch. + (e isa Runtime.DecodeError || k8s_retry_cond(nothing, e)[2]) || rethrow() + finally + isopen(raw) && close(raw) # also releases the stop watcher + try + wait(stopwatcher) # never at the expense of the real error + catch + end + end + if expired + rv, stopped = _resync(ctx, client, op, args, callkwargs; max_tries = max_tries, + push_initial = push_initial) + stopped && return nothing + end + + # A watch that established and then ended without delivering anything is + # not a failure, so `k8s_retry` above never sees it and nothing throttles + # the next attempt. Back off, or a server that keeps closing empty + # streams — an unservable resourceVersion, a proxy dropping long + # connections — turns this loop into a hot one against the apiserver. + if delivered == 0 + idle_restarts += 1 + _backoff(eventstream, min(0.25 * 2.0^min(idle_restarts - 1, 5), 8.0)) else - put!(eventstream, result) + idle_restarts = 0 end end + return nothing +end - # start watch and return the HTTP response object on completion - result = k8s_retry(; max_tries=max_tries, stream=eventstream) do - check_api_response(apicall(apictx, eventstream, args...; watch=watch, resource_version=resource_version, kwargs...)...) - end +""" + _backoff(eventstream, seconds) - return result +Wait, but give up as soon as the consumer stops the watch. +""" +function _backoff(eventstream, seconds) + deadline = time() + seconds + while isopen(eventstream) && time() < deadline + sleep(min(0.1, deadline - time())) + end + return nothing end -function get(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, name::String; - apiversion::Union{String,Nothing}=nothing, - max_tries::Integer=retries(ctx), - watch=isa(ctx, KuberWatchContext), - resource_version=nothing, - namespace::Union{String,Nothing}=_kubectx(ctx).namespace, +# ── verbs ────────────────────────────────────────────────────────────────── + +""" + list(ctx, O; kwargs...) + list(ctx, O, name; kwargs...) + +List objects of kind `O`. In a watch context (or with `watch=true`) this streams +the initial list result followed by `KuberEvent`s, and returns only when the +watch ends. + +**A list object on the stream means complete current state.** It is the first +frame, and it appears again whenever the watch has to resync — when the +`resourceVersion` expires, Kuber lists again rather than replaying, because a +replay would never mention what was deleted in the gap. A consumer keeping its +own cache should discard anything not in that list. `push_initial=false` opts out +of both frames. + +`name` is for the few list operations that take a path parameter of their own — +`custom.metrics.k8s.io` addresses a metric as +`list(ctx, :MetricValue, "pods/*/http_requests")`. It is an error to pass one to +an operation with no such parameter. + +Keyword Args: +- apiversion: force a group version instead of the server's preferred one +- namespace: the namespace to list in; `"*"` for all namespaces, `nothing` for + cluster-scoped kinds +- resource_version: in a watch, resume from this resourceVersion instead of + listing first. Outside one, the k8s "not older than" read — `"0"` means "any + version you have cached", which is the cheap read +- max_tries: retries allowed for the call +- any parameter the operation documents (`label_selector`, `field_selector`, + `limit`, `timeout_seconds`, …), snake_case or lowercase +""" +function list(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, + name::Union{String,Nothing} = nothing; + apiversion::Union{String,Nothing} = nothing, + namespace::Union{String,Nothing} = _kubectx(ctx).namespace, + max_tries::Int = retries(ctx, false), + watch = isa(ctx, KuberWatchContext), + resource_version = nothing, + buffersize::Int = 1024, + push_initial::Bool = true, kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") + mod = _resolve_module(ctx, O, apiversion; max_tries = max_tries) + _, op, params, scope = _find_op(mod, :list, O, namespace) + scope === :namespaced || (namespace = nothing) + (name === nothing || _takes_name(params)) || + throw(ArgumentError("the list operation for $O takes no name")) + client = client_for(ctx, mod) + callkwargs = _op_kwargs(kwargs) - eventstream = isa(ctx, KuberWatchContext) ? ctx.stream : nothing result = nothing - args = Any[name] - _O_ = to_snake_case(string(O)) - if namespaced && !allnamespaces && (apicall = _api_function(ctx, "read_namespaced_$(_O_)")) !== nothing - push!(args, namespace) - elseif (apicall = _api_function(ctx, "read_$(_O_)")) !== nothing - # nothing - else - throw(ArgumentError("No API functions could be located using $O")) - end - if !watch || resource_version === nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, args...; kwargs...)...) + args = _positional(params, namespace, name, nothing) + # Outside a watch, `resource_version` is the k8s "not older than" read: + # the list operation takes it as a query parameter, so forward it. In a + # watch it means something else — where to resume from — and is consumed + # by the pump below rather than sent with this call. G17. + readkwargs = (!watch && resource_version !== nothing) ? + merge(callkwargs, (; resourceversion = String(resource_version))) : + callkwargs + result = k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, request_options = _call_options(ctx), readkwargs...) end end + watch || return result - # if not watching, retuen the first result - watch || (return result) + isa(ctx, KuberWatchContext) || throw(ArgumentError("watching requires a watch context")) if result !== nothing - resource_version = result.metadata.resourceVersion - # push the first Event consisting of existing data - if isnothing(eventstream) - throw(ArgumentError("Event stream not provided in watch mode")) - else - put!(eventstream, result) - end + resource_version = _resource_version(result) + # the event protocol's first item is the initial typed List result + push_initial && put!(ctx.stream, result) end + return _pump_watch(ctx, mod, op, params, namespace, name, callkwargs, resource_version; + max_tries = max_tries, buffersize = buffersize, push_initial = push_initial) +end - # start watch and return the HTTP response object on completion - result = k8s_retry(; max_tries=max_tries, stream=eventstream) do - check_api_response(apicall(apictx, eventstream, args...; watch=watch, resource_version=resource_version, kwargs...)...) - end +""" + get(ctx, O, name; kwargs...) - return result -end +Read one object of kind `O` by name. Accepts the same keyword arguments as +[`list`](@ref), and watches a single object in a watch context. -function get(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol; - apiversion::Union{String,Nothing}=nothing, - label_selector=nothing, - namespace::Union{String,Nothing}=_kubectx(ctx).namespace, - max_tries::Integer=retries(ctx, false), - watch=isa(ctx, KuberWatchContext), - resource_version=nothing, +`resource_version` works here as it does on `list` — outside a watch it is the +"not older than" read. Kubernetes' OpenAPI document does not declare the +parameter on read operations even though the apiserver honours it, so the +generation pipeline adds it (`patch_k8s_spec.jq` §8). +""" +function get(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol, name::String; + apiversion::Union{String,Nothing} = nothing, + namespace::Union{String,Nothing} = _kubectx(ctx).namespace, + max_tries::Integer = retries(ctx, false), + watch = isa(ctx, KuberWatchContext), + resource_version = nothing, + buffersize::Int = 1024, + push_initial::Bool = true, kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") + mod = _resolve_module(ctx, O, apiversion; max_tries = max_tries) + _, op, params, scope = _find_op(mod, :get, O, namespace) + scope === :namespaced || (namespace = nothing) + client = client_for(ctx, mod) + callkwargs = _op_kwargs(kwargs) - eventstream = isa(ctx, KuberWatchContext) ? ctx.stream : nothing result = nothing - args = Any[] - _O_ = to_snake_case(string(O)) - apiname = "list_$(_O_)" - if allnamespaces && (apicall = _api_function(ctx, apiname * "_for_all_namespaces")) !== nothing - #nothing - elseif namespaced && (apicall = _api_function(ctx, "list_namespaced_$(_O_)")) !== nothing - push!(args, namespace) - elseif (apicall = _api_function(ctx, apiname)) !== nothing - #nothing - elseif (apicall = _api_function(ctx, apiname * "_for_all_namespaces")) !== nothing - #nothing - else - throw(ArgumentError("No API functions could be located using $O")) - end - if !watch || resource_version === nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, args...; label_selector, kwargs...)...) + args = _positional(params, namespace, name, nothing) + # As in `list`: outside a watch this is the "not older than" read, which + # the operation takes as a query parameter. k8s does not document it on + # reads — patch rule §8 declares it, because the apiserver honours it. + # Inside a watch it means where to resume from, and is used below. G17. + readkwargs = (!watch && resource_version !== nothing) ? + merge(callkwargs, (; resourceversion = String(resource_version))) : + callkwargs + result = k8s_retry(; max_tries = Int(max_tries)) do + _call(op, args...; client, request_options = _call_options(ctx), readkwargs...) end end + watch || return result - # if not watching, retuen the first result - watch || (return result) + isa(ctx, KuberWatchContext) || throw(ArgumentError("watching requires a watch context")) if result !== nothing - resource_version = result.metadata.resourceVersion - # push the first Event consisting of existing data - if isnothing(eventstream) - throw(ArgumentError("Event stream not provided in watch mode")) - else - put!(eventstream, result) - end + resource_version = _resource_version(result) + push_initial && put!(ctx.stream, result) end + # A read op has no watch mode — only collections do — so watch the collection + # narrowed to this one object, preserving any field selector the caller gave + # (k8s ANDs comma-separated selectors). + _, listop, listparams, listscope = _find_op(mod, :list, O, namespace) + selector = haskey(callkwargs, :fieldselector) ? + "$(callkwargs.fieldselector),metadata.name=$name" : "metadata.name=$name" + return _pump_watch(ctx, mod, listop, listparams, listscope === :namespaced ? namespace : nothing, + nothing, merge(callkwargs, (; fieldselector = selector)), + resource_version; max_tries = Int(max_tries), buffersize = buffersize, + push_initial = push_initial) +end - # start watch and return the HTTP response object on completion - result = k8s_retry(; max_tries=max_tries, stream=eventstream) do - check_api_response(apicall(apictx, eventstream, args...; watch=watch, resource_version=resource_version, label_selector, kwargs...)...) - end +""" + get(ctx, O; kwargs...) - return result -end +List objects of kind `O` — the collection form of [`get`](@ref), equivalent to +[`list`](@ref). +""" +get(ctx::Union{KuberContext,KuberWatchContext}, O::Symbol; kwargs...) = list(ctx, O; kwargs...) -function watch(ctx::KuberContext, O::Symbol, outstream::Channel, name::String; - apiversion::Union{String,Nothing}=nothing, - namespace::Union{String,Nothing}=ctx.namespace, - max_tries::Int=retries(ctx, false), - kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") - _O_ = to_snake_case(string(O)) - result = nothing +""" + put!(ctx, obj) + put!(ctx, O, obj) - if allnamespaces - apicall = apimodule(ctx).eval(Symbol("watch_$(_O_)_for_all_namespaces")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream, name; kwargs...)...) - end - elseif namespaced - apicall = apimodule(ctx).eval(Symbol("watch_namespaced_$(_O_)")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream, name, namespace; kwargs...)...) - end - else - apicall = apimodule(ctx).eval(Symbol("watch_$(_O_)")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream, name; kwargs...)...) - end - end +Create an object. `obj` is a model or a JSON object; `O` is its kind, inferred +from the object when not given. +""" +function put!(ctx::KuberContext, v; max_tries::Int = retries(ctx, true), kwargs...) + kind = kuber_kind(v) + isempty(kind) && throw(ArgumentError("kind must be specified for $(typeof(v))")) + put!(ctx, Symbol(kind), v; max_tries = max_tries, kwargs...) +end - return result +function put!(ctx::KuberContext, O::Symbol, v::AbstractDict; max_tries::Int = retries(ctx, true), kwargs...) + haskey(v, "kind") || (v = merge(Dict{String,Any}("kind" => String(O)), v)) + put!(ctx, O, kuber_obj(v); max_tries = max_tries, kwargs...) end -function watch(ctx::KuberContext, O::Symbol, outstream::Channel; - apiversion::Union{String,Nothing}=nothing, - namespace::Union{String,Nothing}=ctx.namespace, - max_tries::Int=retries(ctx, false), +function put!(ctx::KuberContext, O::Symbol, v; + apiversion::Union{String,Nothing} = _field(hasproperty(v, :apiversion) ? v.apiversion : nothing), + namespace::Union{String,Nothing} = ctx.namespace, + max_tries::Int = retries(ctx, true), kwargs...) - apictx = _get_apictx(ctx, O, apiversion; max_tries=max_tries) - namespaced = (namespace !== nothing) && !isempty(namespace) - allnamespaces = namespaced && (namespace == "*") - _O_ = to_snake_case(string(O)) - result = nothing - - if allnamespaces - apicall = apimodule(ctx).eval(Symbol("watch_$(_O_)_for_all_namespaces")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream; kwargs...)...) - end - elseif namespaced - apicall = apimodule(ctx).eval(Symbol("watch_namespaced_$(_O_)")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream, namespace; kwargs...)...) - end - else - apicall = apimodule(ctx).eval(Symbol("watch_$(_O_)")) - result = k8s_retry(; max_tries=max_tries, stream=outstream) do - check_api_response(apicall(apictx, outstream; kwargs...)...) - end + mod = _resolve_module(ctx, O, apiversion) + _, op, params, scope = _find_op(mod, :create, O, namespace) + scope === :namespaced || (namespace = nothing) + args = _positional(params, namespace, nothing, v) + client = client_for(ctx, mod) + callkwargs = _op_kwargs(kwargs) + return k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, request_options = _call_options(ctx), callkwargs...) end - - return result end -function put!(ctx::KuberContext, v::T; max_tries::Int=retries(ctx, true)) where {T<:OpenAPI.APIModel} - if isnothing(v.kind) - throw(ArgumentError("kind must be specified for $T")) - end - put!(ctx, Symbol(v.kind), v; max_tries=max_tries) +""" + delete!(ctx, obj) + delete!(ctx, O, name) + +Delete an object. Note that a delete can return either the deleted object or a +`Status` — see https://github.com/kubernetes-client/csharp/issues/44 — and that +the two are types from possibly different group modules, so compare +`kuber_kind(result)` rather than the type. + +Because of that ambiguity the delete operations are the one place where the +patched specs describe the response as "anything" (see `patch_k8s_spec.jq` rule +5), so the payload's own `kind`/`apiVersion` is what types the result here. +""" +function delete!(ctx::KuberContext, v; max_tries::Int = retries(ctx, true), kwargs...) + kind = kuber_kind(v) + isempty(kind) && throw(ArgumentError("kind must be specified for $(typeof(v))")) + metadata = _field(v.metadata) + name = metadata === nothing ? nothing : _field(metadata.name) + name === nothing && throw(ArgumentError("metadata.name must be specified for $(typeof(v))")) + apiversion = _field(hasproperty(v, :apiversion) ? v.apiversion : nothing) + delete!(ctx, Symbol(kind), String(name); apiversion = apiversion, max_tries = max_tries, kwargs...) end -function put!(ctx::KuberContext, O::Symbol, v::Dict{String,Any}; max_tries::Int=retries(ctx, true)) - if isnothing(v["kind"]) - v["kind"] = string(O) +function delete!(ctx::KuberContext, O::Symbol, name::String; + apiversion::Union{String,Nothing} = nothing, + namespace::Union{String,Nothing} = ctx.namespace, + max_tries::Int = retries(ctx, true), + kwargs...) + mod = _resolve_module(ctx, O, apiversion) + _, op, params, scope = _find_op(mod, :delete, O, namespace) + scope === :namespaced || (namespace = nothing) + args = _positional(params, namespace, name, nothing) + client = client_for(ctx, mod) + callkwargs = _op_kwargs(kwargs) + result = k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, request_options = _call_options(ctx), callkwargs...) end - put!(ctx, O, kuber_obj(ctx, v); max_tries=max_tries) + return _typed_result(result) end -function put!(ctx::KuberContext, O::Symbol, v::T; max_tries::Int=retries(ctx, true)) where {T<:OpenAPI.APIModel} - apictx = _get_apictx(ctx, O, v.apiVersion) - _O_ = to_snake_case(string(O)) - result = nothing - if (apicall = _api_function(ctx, "create_$(_O_)")) !== nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, v)...) - end - elseif (apicall = _api_function(ctx, "create_namespaced_$(_O_)")) !== nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, ctx.namespace, v)...) - end - else - throw(ArgumentError("No API functions could be located using $O")) +""" + _typed_result(result) + +Type an untyped (`Any`-schema) response from its own `kind`/`apiVersion`, +leaving it alone if the kind is unknown to this build. +""" +function _typed_result(result) + result isa AbstractDict && haskey(result, "kind") || return result + return try + kuber_obj(result) + catch + result end - return result end -# Note: delete! operations can return either the deleted object or a status object -# ref: https://github.com/kubernetes-client/csharp/issues/44 -function delete!(ctx::KuberContext, v::T; max_tries::Int=retries(ctx, true), kwargs...) where {T<:OpenAPI.APIModel} - vjson = convert(Dict{String,Any}, v) - kind = vjson["kind"] - name = vjson["metadata"]["name"] - delete!(ctx, Symbol(kind), name; apiversion=get(vjson, "apiVersion", nothing), max_tries=max_tries, kwargs...) -end +""" + _patch_payload(patch) -> AbstractDict | AbstractVector -function delete!(ctx::KuberContext, O::Symbol, name::String; apiversion::Union{String,Nothing}=nothing, max_tries::Int=retries(ctx, true), kwargs...) - apictx = _get_apictx(ctx, O, apiversion) - _O_ = to_snake_case(string(O)) - params = [apictx, name] - result = nothing +Normalize whatever a caller passes as a patch into something the generated body +type can be decoded from. - if (apicall = _api_function(ctx, "delete_$(_O_)")) !== nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(params...; kwargs...)...) - end - elseif (apicall = _api_function(ctx, "delete_namespaced_$(_O_)")) !== nothing - push!(params, ctx.namespace) - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(params...; kwargs...)...) - end - else - throw(ArgumentError("No API functions could be located using $O")) - end +Two shapes reach here besides a plain dictionary or vector. JSON **text** is +parsed — that is what the 0.2.x client accepted. A **generated model** is +encoded to its JSON object first: patching an object with a whole desired object +is how JuliaRun updates Secrets (`api.jl:252`), and a model cannot be decoded +into the open `Patch` struct directly, which wants an object rather than a +struct. +""" +_patch_payload(patch) = Runtime._encode(patch) +_patch_payload(patch::AbstractString) = JSON.parse(patch) +_patch_payload(patch::AbstractDict) = patch +_patch_payload(patch::AbstractVector) = patch - return result -end +""" + update!(ctx, obj, patch, patch_type) + update!(ctx, O, name, patch, patch_type) -function update!(ctx::KuberContext, v::T, patch, patch_type; max_tries::Int=retries(ctx, true)) where {T<:OpenAPI.APIModel} - vjson = convert(Dict{String,Any}, v) - kind = vjson["kind"] - name = vjson["metadata"]["name"] - update!(ctx, Symbol(kind), name, patch, patch_type; apiversion=get(vjson, "apiVersion", nothing), max_tries=max_tries) -end +Patch an object. `patch_type` is the patch media type, and must be one k8s +documents for a PATCH — `"application/merge-patch+json"`, +`"application/strategic-merge-patch+json"`, `"application/json-patch+json"`, +`"application/apply-patch+yaml"` or `"application/apply-patch+cbor"`. There is +no plain `application/json` variant. -function update!(ctx::KuberContext, O::Symbol, name::String, patch, patch_type; apiversion::Union{String,Nothing}=nothing, max_tries::Int=retries(ctx, true)) - apictx = _get_apictx(ctx, O, apiversion) - _O_ = to_snake_case(string(O)) - result = nothing +The shape of `patch` follows the media type, as the protocol requires: - if (apicall = _api_function(ctx, "patch_$(_O_)")) !== nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, name, patch; _mediaType=patch_type)...) - end - elseif (apicall = _api_function(ctx, "patch_namespaced_$(_O_)")) !== nothing - result = k8s_retry(; max_tries=max_tries) do - check_api_response(apicall(apictx, name, ctx.namespace, patch; _mediaType=patch_type)...) - end - else - throw(ArgumentError("No API functions could be located using $O")) +- a **merge, strategic-merge or apply patch** is an object — a `Dict`, a model, + or JSON text — merged into the target: `Dict("spec" => Dict("replicas" => 2))` +- a **json-patch** is an array of RFC 6902 operations: + `[Dict("op" => "replace", "path" => "/spec/replicas", "value" => 2)]` + +An object patch may equally be a generated model or JSON text (see +`_patch_payload`); a json-patch may be a vector or the JSON text of one. + +Kubernetes' OpenAPI document declares one object schema for all five, which is +untrue of json-patch; `gen/openapi_v1/patch_k8s_spec.jq` §6 corrects it, and +`OP_BODIES` carries the resulting type per media type. +""" +function update!(ctx::KuberContext, v, patch, patch_type; max_tries::Int = retries(ctx, true), kwargs...) + kind = kuber_kind(v) + isempty(kind) && throw(ArgumentError("kind must be specified for $(typeof(v))")) + metadata = _field(v.metadata) + name = metadata === nothing ? nothing : _field(metadata.name) + name === nothing && throw(ArgumentError("metadata.name must be specified for $(typeof(v))")) + apiversion = _field(hasproperty(v, :apiversion) ? v.apiversion : nothing) + update!(ctx, Symbol(kind), String(name), patch, patch_type; + apiversion = apiversion, max_tries = max_tries, kwargs...) +end + +function update!(ctx::KuberContext, O::Symbol, name::String, patch, patch_type; + apiversion::Union{String,Nothing} = nothing, + namespace::Union{String,Nothing} = ctx.namespace, + max_tries::Int = retries(ctx, true), + kwargs...) + mod = _resolve_module(ctx, O, apiversion) + key, op, params, scope = _find_op(mod, :patch, O, namespace) + scope === :namespaced || (namespace = nothing) + media = OP_BODIES[key] + bodytype = get(media, String(patch_type), nothing) + bodytype === nothing && throw(ArgumentError( + "unsupported patch type $patch_type for $O; the API documents $(join(sort!(collect(keys(media))), ", "))")) + # The body type depends on the media type: a merge, strategic-merge or apply + # patch is the generated `Patch` model (an open object), a json-patch is the + # `JSONPatch` array of operations. Either way a caller's plain Dict or Vector + # has to be decoded into it rather than passed through. A patch handed over + # as JSON text is parsed first — that is what the 0.2.x client accepted. + body = patch isa bodytype ? patch : Runtime._decode(bodytype, _patch_payload(patch), false) + args = _positional(params, namespace, name, body) + client = client_for(ctx, mod) + callkwargs = _op_kwargs(kwargs) + return k8s_retry(; max_tries = max_tries) do + _call(op, args...; client, content_type = patch_type, + request_options = _call_options(ctx), callkwargs...) end - return result end """ @@ -419,21 +739,64 @@ Parameters: Keyword Args: - container::String : The container for which to stream logs. Defaults to only container if there is one container in the pod. - follow::Bool : Follow the log stream of the pod. Defaults to false. -- limitBytes::Int32 : If set, the number of bytes to read from the server before terminating the log output. This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit. +- limit_bytes::Int64 : If set, the number of bytes to read from the server before terminating the log output. This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit. - pretty::String : If 'true', then the output is pretty printed. - previous::Bool : Return previous terminated container logs. Defaults to false. -- sinceSeconds::Int32 : A relative time in seconds before the current time from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified. -- sinceTime::String : An RFC3339 timestamp from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified. -- tailLines::Int32 : If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation of the container or sinceSeconds or sinceTime +- since_seconds::Int64 : A relative time in seconds before the current time from which to show logs. If this value precedes the time a pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will be returned. Only one of since_seconds or since_time may be specified. +- tail_lines::Int64 : If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation of the container or since_seconds or since_time - timestamps::Bool : If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false. Returns: String of all log entries, one per line """ get_logs(ctx::KuberContext, pod_name::String; kwargs...) = get(ctx, :PodLog, pod_name; kwargs...) -list_namespaced_custom_metrics(ctx::KuberContext, metricname::String; kwargs...) = list(ctx, :MetricValue, "metrics/"*metricname; kwargs...) -list_namespaced_custom_metrics(ctx::KuberContext, objecttype::String, metricname::String; kwargs...) = list(ctx, :MetricValue, objecttype * "/*/" * metricname; kwargs...) -list_namespaced_custom_metrics(ctx::KuberContext, objecttype::String, objectname::String, metricname::String; kwargs...) = list(ctx, :MetricValue, objecttype * "/" * objectname * "/" * metricname; kwargs...) +""" + _composite_metric_name(metricname) -> String + _composite_metric_name(objecttype, metricname) -> String + _composite_metric_name(objecttype, objectname, metricname) -> String + +The path segment `custom.metrics.k8s.io` addresses a metric by: +`metrics/` for every object in the namespace, +`/*/` for every object of a type, and +`//` for one object. +""" +_composite_metric_name(metricname::String) = "metrics/" * metricname +_composite_metric_name(objecttype::String, metricname::String) = objecttype * "/*/" * metricname +_composite_metric_name(objecttype::String, objectname::String, metricname::String) = + objecttype * "/" * objectname * "/" * metricname -list_custom_metrics(ctx::KuberContext, objecttype::String, metricname::String; kwargs...) = list(ctx, :MetricValue, objecttype * "/*/" * metricname; namespace=nothing, kwargs...) -list_custom_metrics(ctx::KuberContext, objecttype::String, objectname::String, metricname::String; kwargs...) = list(ctx, :MetricValue, objecttype * "/" * objectname * "/" * metricname; namespace=nothing, kwargs...) +""" + list_namespaced_custom_metrics(ctx, metricname; kwargs...) + list_namespaced_custom_metrics(ctx, objecttype, metricname; kwargs...) + list_namespaced_custom_metrics(ctx, objecttype, objectname, metricname; kwargs...) + +Read a custom metric for objects in `ctx`'s namespace. + +`custom.metrics.k8s.io` addresses a metric by a *composite name* rather than by +a resource name: `metrics/` for every object in the namespace, +`/*/` for every object of a type, and +`//` for one object. These build that name. + +The group is served by a metrics adapter (prometheus-adapter and the like), not +by the apiserver, so it is not in Kubernetes' own OpenAPI documents and Kuber +does not ship it. Capture it from a cluster that serves it and register it: + +```sh +gen/openapi_v1/fetch_specs.sh --from-cluster custom.metrics.k8s.io/v1beta1 +``` + +See `Metrics.md`, and [`Kuber.register!`](@ref) for plugging the generated +module in. +""" +list_namespaced_custom_metrics(ctx::KuberContext, args::String...; kwargs...) = + list(ctx, :MetricValue, _composite_metric_name(args...); kwargs...) + +""" + list_custom_metrics(ctx, objecttype, metricname; kwargs...) + list_custom_metrics(ctx, objecttype, objectname, metricname; kwargs...) + +Read a custom metric for cluster-scoped objects — the same composite naming as +[`list_namespaced_custom_metrics`](@ref), without a namespace. +""" +list_custom_metrics(ctx::KuberContext, objecttype::String, rest::String...; kwargs...) = + list(ctx, :MetricValue, _composite_metric_name(objecttype, rest...); namespace = nothing, kwargs...) diff --git a/test/characterize_retries.jl b/test/characterize_retries.jl new file mode 100644 index 00000000..d6c4fa29 --- /dev/null +++ b/test/characterize_retries.jl @@ -0,0 +1,293 @@ +# Retry-condition characterization (OpenAPIv1TrialBranchPlan.md §4.3). +# +# NOT part of runtests.jl — a manual tool. Run it to pin down exactly which +# exception types the pinned OpenAPI.jl runtime raises for each failure mode +# Kuber's `k8s_retry_cond` has to classify, then encode what it prints in +# `k8s_retry_cond`. Rerun it whenever the OpenAPI pin moves: these are runtime +# internals, not a stable contract. +# +# This file characterizes the *classification* — which exception means what. The +# retry *loop* built on it is exercised by test/retries.jl, which is in +# runtests.jl and drives a fake apiserver. Two things changed under that loop +# after this file was written (OpenAPIv1ConsumerGaps.md G19/G20), and they do +# not affect what is printed here but do affect how to read it: +# +# - 429 is now retryable, and a 429's `Retry-After` lengthens the wait. +# - `k8s_retry` is an explicit loop rather than `Base.retry`, and `max_tries` +# counts attempts rather than retries. HTTP.jl's own retry layer is switched +# off per call, so Kuber's loop is the only one. +# +# kubectl proxy --port=8801 & +# julia --project test/characterize_retries.jl +# +# The four modes, and why each matters: +# +# 1. retryable HTTP status (503) — the old code matched +# `OpenAPI.Clients.ApiException.status` +# 2. connection refused / transport failure — the old code used +# `OpenAPI.Clients.is_request_interrupted`, which no longer exists +# 3. consumer closes a watch channel — MUST NOT be retried (Kuber #68); the +# old guard was `stream === nothing || isopen(stream)` +# 4. server truncates a watch stream mid-item — new in the 1.0 runtime, which +# closes the channel with a DecodeError instead of ending silently +# +# Findings at OpenAPI 1ff9ba8 / HTTP 2.6.4 / k8s v1.35.4 (2026-08-13), which is +# what src/helpers.jl encodes: +# +# 503 status -> OpenAPI.Runtime.ApiError, .status == 503. `.decoded` +# is raw Vector{UInt8} for statuses the document does +# not describe, so KuberException parses the body itself +# connection refused -> HTTP.ConnectError (NOT an ApiError). Transport +# failures are HTTP.jl exceptions now; the old +# `is_request_interrupted` helper is gone +# consumer close -> the watch call does not throw AT ALL. It returns at +# the response head, so by the time a consumer closes +# the channel there is no in-flight call to retry. Watch +# failures surface on the channel, not from the call — +# which is why retry-vs-stop lives in the re-watch loop +# truncated stream -> channel closes with OpenAPI.Runtime.DecodeError +# ("streaming response ended with a truncated item") +# dropped connection -> on an item boundary this is a CLEAN close, +# indistinguishable from a watch ending normally. So a +# clean close cannot mean "stop": only the consumer +# closing the channel means that +# 410 Gone -> NOT an ApiError. k8s answers an expired +# resourceVersion with HTTP 200 and an in-stream +# {"type": "ERROR", "object": Status(reason=Expired, +# code=410)} event (plan §5.3 assumed an ApiError) +using HTTP, JSON, Sockets, Kuber + +const K8s = Kuber.ApiImpl.K8sV1 +const PROXY = "http://127.0.0.1:8801" + +describe(e) = string(typeof(e)) + +function report(label, e) + println("\n── ", label) + println(" type: ", describe(e)) + if e isa K8s.ApiError + println(" status: ", e.status) + println(" opid: ", e.operation_id) + println(" decoded: ", e.decoded === nothing ? "nothing" : describe(e.decoded)) + println(" body: ", isvalid(String, e.body) ? first(String(copy(e.body)), 120) : "$(length(e.body)) bytes") + end + for f in fieldnames(typeof(e)) + f in (:body, :decoded, :headers, :decoded_headers) && continue + v = getfield(e, f) + v isa Exception && println(" .", f, " = ", describe(v), ": ", sprint(showerror, v)[1:min(end, 160)]) + end + println(" showerror: ", sprint(showerror, e)[1:min(end, 200)]) + return typeof(e) +end + +""" +Serve one canned response on an ephemeral port; returns `(url, stopper)`. + +Raw TCP rather than `HTTP.listen!` so the response bytes — including a +deliberately truncated body and a connection dropped with no terminator — are +under our control exactly. +""" +function fakeserver(respond) + server = Sockets.listen(Sockets.localhost, 0) + port = Int(Sockets.getsockname(server)[2]) + @async try + while true + sock = Sockets.accept(server) + @async try + while true # drain the request head + line = readline(sock) + (isempty(line) || line == "\r") && break + end + respond(sock) + catch + finally + close(sock) + end + end + catch + end + return "http://127.0.0.1:$port", () -> close(server) +end + +"""Response head with no Content-Length: the body ends when the socket closes.""" +function streaming_head(sock, status = 200) + write(sock, "HTTP/1.1 $status OK\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n") + flush(sock) +end + +const WATCH_EVENT = JSON.json(Dict("type" => "ADDED", + "object" => Dict("kind" => "Pod", "apiVersion" => "v1", + "metadata" => Dict("name" => "p1", "resourceVersion" => "1")))) + +results = Pair{String,Any}[] + +# ── 1. retryable status ──────────────────────────────────────────────────── +let + body = JSON.json(Dict("kind" => "Status", "apiVersion" => "v1", "status" => "Failure", + "message" => "the server is currently unable to handle the request", + "reason" => "ServiceUnavailable", "code" => 503)) + url, stop = fakeserver() do sock + write(sock, "HTTP/1.1 503 Service Unavailable\r\nContent-Type: application/json\r\n", + "Content-Length: $(sizeof(body))\r\nConnection: close\r\n\r\n", body) + flush(sock) + end + client = K8s.Client(url; require_credentials = false) + e = try + K8s.listcorev1namespacedpod("default"; client) + nothing + catch err + err + end + push!(results, "503 status" => report("503 from server", e)) + stop() +end + +# ── 2. transport failure (nothing listening) ─────────────────────────────── +let + client = K8s.Client("http://127.0.0.1:1"; require_credentials = false) + e = try + K8s.listcorev1namespacedpod("default"; client) + nothing + catch err + err + end + push!(results, "connection refused" => report("connection refused", e)) +end + +# ── 3. consumer closes the watch channel (must NOT retry) ────────────────── +let + client = K8s.Client(PROXY; require_credentials = false) + K8s.codec!(client, "application/json;stream=watch"; decode = (bytes, _) -> JSON.parse(String(bytes))) + pods = K8s.listcorev1namespacedpod("default"; client) + events = Channel{Any}(16) + e = try + K8s.listcorev1namespacedpod("default"; client, watch = true, + resourceversion = pods.metadata.resourceversion, + accept = "application/json;stream=watch", stream_to = events) + sleep(0.5) + close(events) # the documented way for a consumer to stop a watch + sleep(1.5) + nothing # did the call itself throw? + catch err + err + end + println("\n── consumer close(events)") + println(" call threw: ", e === nothing ? "no" : describe(e)) + println(" isopen: ", isopen(events)) + tk = try + take!(events) + "value" + catch err + describe(err) + end + println(" take! after: ", tk) + push!(results, "consumer close" => (e === nothing ? "no throw" : describe(e))) +end + +# ── 4. server truncates a watch stream mid-item ──────────────────────────── +let + url, stop = fakeserver() do sock + streaming_head(sock) + write(sock, WATCH_EVENT, "\n") # one complete event… + flush(sock) + sleep(0.3) + write(sock, "{\"type\": \"ADDED\", \"object\": {\"kind\": ") # …then a truncated one + flush(sock) + end + client = K8s.Client(url; require_credentials = false) + K8s.codec!(client, "application/json;stream=watch"; decode = (bytes, _) -> JSON.parse(String(bytes))) + events = Channel{Any}(16) + K8s.listcorev1namespacedpod("default"; client, watch = true, + accept = "application/json;stream=watch", stream_to = events) + got = Any[] + e = try + for ev in events + push!(got, ev) + end + nothing + catch err + err + end + println("\n── truncated stream") + println(" items before failure: ", length(got)) + e === nothing ? println(" channel closed cleanly (no error)") : report("truncated stream", e) + push!(results, "truncated stream" => (e === nothing ? "clean close" : describe(e))) + stop() +end + +# ── 5. server drops a live watch connection mid-stream ───────────────────── +let + url, stop = fakeserver() do sock + streaming_head(sock) + write(sock, WATCH_EVENT, "\n") + flush(sock) + sleep(0.3) # then drop, on an item boundary + end + client = K8s.Client(url; require_credentials = false) + K8s.codec!(client, "application/json;stream=watch"; decode = (bytes, _) -> JSON.parse(String(bytes))) + events = Channel{Any}(16) + e = try + K8s.listcorev1namespacedpod("default"; client, watch = true, + accept = "application/json;stream=watch", stream_to = events) + got = Any[] + for ev in events + push!(got, ev) + end + println("\n── dropped connection: ", length(got), " items, channel closed cleanly") + nothing + catch err + err + end + e === nothing || report("dropped connection", e) + push!(results, "dropped connection" => (e === nothing ? "clean close" : describe(e))) + stop() +end + +# ── 6. 410 Gone: a watch resumed from an expired resourceVersion ─────────── +# k8s's watch protocol answer to "your resourceVersion is too old"; §5.3 has to +# turn it into a fresh list+watch rather than a retry of the same call. +let + client = K8s.Client(PROXY; require_credentials = false) + K8s.codec!(client, "application/json;stream=watch"; decode = (bytes, _) -> JSON.parse(String(bytes))) + events = Channel{Any}(8) + e = try + K8s.listcorev1namespacedpod("default"; client, watch = true, + resourceversion = "1", timeoutseconds = Int64(5), + accept = "application/json;stream=watch", stream_to = events) + nothing + catch err + err + end + println("\n── expired resourceVersion") + if e === nothing + println(" call threw: no — reading the stream instead") + got = Any[] + streamerr = try + for ev in events + push!(got, ev) + length(got) >= 3 && break + end + nothing + catch err + err + end + for ev in got + println(" event: type=", get(ev, "type", "?"), + " object.kind=", get(get(ev, "object", Dict()), "kind", "?"), + " reason=", get(get(ev, "object", Dict()), "reason", "-"), + " code=", get(get(ev, "object", Dict()), "code", "-")) + end + streamerr === nothing || println(" stream error: ", describe(streamerr)) + push!(results, "410 Gone" => isempty(got) ? "no events" : + "in-stream $(get(got[1], "type", "?")) event, code=$(get(get(got[1], "object", Dict()), "code", "-"))") + close(events) + else + report("expired resourceVersion (410 Gone)", e) + push!(results, "410 Gone" => describe(e) * (e isa K8s.ApiError ? " status=$(e.status)" : "")) + end +end + +println("\n\n════ SUMMARY ════") +for (label, T) in results + println(" ", rpad(label, 22), " -> ", T) +end diff --git a/test/helpers.jl b/test/helpers.jl new file mode 100644 index 00000000..b84c6697 --- /dev/null +++ b/test/helpers.jl @@ -0,0 +1,333 @@ +# Offline checks on src/helpers.jl: context, conversions, exceptions, retry +# classification, request options. No cluster needed (Phase 2 gate, §6.2). +using Kuber, HTTP, JSON, Test + +const R = Kuber.ApiImpl +const Runtime = Kuber.Runtime + +const POD_JSON = """{ + "kind": "Pod", + "apiVersion": "v1", + "metadata": {"name": "somepod", "namespace": "default", "labels": {"name": "somepod"}}, + "spec": {"containers": [{"name": "nginx", "image": "nginx"}]} +}""" + +@testset "helpers" begin + @testset "context defaults" begin + ctx = KuberContext() + @test get_server(ctx) == "http://localhost:8001" + @test get_ns(ctx) == "default" + @test !ctx.initialized + @test isempty(ctx.clients) + @test Kuber.retries(ctx, true) == 1 # mutating calls don't retry by default + @test Kuber.retries(ctx, false) == 5 + set_retries(ctx; count = 3, all_apis = true) + @test Kuber.retries(ctx, true) == 3 + set_ns(ctx, "kube-system") + @test get_ns(ctx) == "kube-system" + @test sprint(show, ctx) == "Kubernetes namespace kube-system at http://localhost:8001" + end + + @testset "set_server resets clients" begin + ctx = KuberContext() + core = R.GROUP_MODULES["v1"] + client = Kuber.client_for(ctx, core) + @test client === Kuber.client_for(ctx, core) # cached per module + @test Kuber.client_for(ctx, R.GROUP_MODULES["apps/v1"]) !== client + set_server(ctx, "http://127.0.0.1:8801") + @test get_server(ctx) == "http://127.0.0.1:8801" + @test isempty(ctx.clients) + @test Kuber.client_for(ctx, core) !== client + end + + @testset "watch codec is registered, scoped to the accept media" begin + ctx = KuberContext() + client = Kuber.client_for(ctx, R.GROUP_MODULES["v1"]) + @test haskey(client.media_decoders, Kuber.WATCH_MEDIA) + @test !haskey(client.media_decoders, "application/json") + end + + @testset "kuber_obj / kuber_type / kind_to_type" begin + pod = kuber_obj(POD_JSON) + @test pod isa R.KIND_TYPES[("v1", "Pod")] + @test pod.metadata.name == "somepod" + @test kuber_kind(pod) == "Pod" + # absent optional fields are ABSENT now, not nothing + @test pod.status isa Runtime.Absent + @test Kuber._field(pod.status) === nothing + @test Kuber._field(pod.status, :fallback) === :fallback + @test Kuber._field(pod.metadata.name) == "somepod" + + @test kuber_obj(JSON.parse(POD_JSON)) isa R.KIND_TYPES[("v1", "Pod")] + @test kuber_type(JSON.parse(POD_JSON)) === R.KIND_TYPES[("v1", "Pod")] + # apiVersion defaults to core v1 when the payload omits it + @test kuber_type(Dict("kind" => "Pod")) === R.KIND_TYPES[("v1", "Pod")] + + ctx = KuberContext() + @test kind_to_type(ctx, :Pod, "v1") === R.KIND_TYPES[("v1", "Pod")] + @test kind_to_type(ctx, "PodList", "v1") === R.KIND_TYPES[("v1", "PodList")] + @test kind_to_type(ctx, :Deployment, "apps/v1") === R.KIND_TYPES[("apps/v1", "Deployment")] + @test_throws KeyError kind_to_type(ctx, :Pod, "apps/v1") + end + + @testset "kuber_props reads open string maps" begin + pod = kuber_obj("""{"kind": "Pod", "apiVersion": "v1", + "metadata": {"name": "p", "labels": {"a": "b"}, + "annotations": {"seq": "7", "other": "x"}}, + "spec": {"containers": [{"name": "c", "image": "busybox"}]}}""") + # k8s string maps generate an open struct, not a Dict, so indexing the + # field directly does not work — this is the trap kuber_props exists for + @test !(pod.metadata.annotations isa AbstractDict) + @test kuber_props(pod.metadata.annotations)["seq"] == "7" + @test kuber_props(pod.metadata.labels)["a"] == "b" + + # ABSENT, null, and a plain Dict all normalize + bare = kuber_obj("""{"kind": "Pod", "apiVersion": "v1", "metadata": {"name": "p"}}""") + @test kuber_props(bare.metadata.annotations) == Dict{String,String}() + @test kuber_props(bare.metadata.annotations, Dict("d" => "1")) == Dict("d" => "1") + @test kuber_props(nothing) == Dict{String,String}() + @test kuber_props(Dict("k" => "v")) == Dict("k" => "v") + end + + @testset "getpropertyat / haspropertyat" begin + # The C2 replacements for the accessors OpenAPI.jl 1.0 dropped. Not + # exported: a shim for consumers porting off 0.2.x, where JuliaRun alone + # has 49 call sites. + pod = kuber_obj("""{"kind": "Pod", "apiVersion": "v1", + "metadata": {"name": "p", "namespace": "ns", "labels": {"app": "web"}}, + "spec": {"nodeName": "node-1", + "containers": [{"name": "c", "image": "busybox"}, + {"name": "d", "image": "alpine"}]}}""") + + @test Kuber.getpropertyat(pod, :metadata, :name) == "p" + @test Kuber.getpropertyat(pod, :spec, :containers, 1, :image) == "busybox" + @test Kuber.haspropertyat(pod, :metadata, :namespace) + + # the generated field name is the lowercased JSON one (C4): nodename, + # not nodeName. A wrong name reads as absent rather than being folded, + # so a typo stays a bug. + @test Kuber.getpropertyat(pod, :spec, :nodename) == "node-1" + @test Kuber.getpropertyat(pod, :spec, :nodeName) === nothing + @test !Kuber.haspropertyat(pod, :spec, :nodeName) + + # ABSENT is absent. This is the whole point: on 1.0 every field exists, + # so a plain `hasproperty` walk answers true for everything — the trap + # that makes JuliaRun's container_resource return ABSENT instead of + # falling through to limits. + @test pod.status isa Runtime.Absent + @test hasproperty(pod, :status) # …which is why this is useless + @test !Kuber.haspropertyat(pod, :status) + @test !Kuber.haspropertyat(pod, :status, :phase) + @test Kuber.getpropertyat(pod, :status, :phase) === nothing + + # an open-struct entry is reachable as a path element, so a label does + # not need a separate kuber_props call + @test Kuber.getpropertyat(pod, :metadata, :labels, "app") == "web" + @test Kuber.haspropertyat(pod, :metadata, :labels, "app") + @test !Kuber.haspropertyat(pod, :metadata, :labels, "missing") + + # a vector met by a non-integer element is mapped over, as on 0.x + @test Kuber.getpropertyat(pod, :spec, :containers, :name) == ["c", "d"] + @test Kuber.haspropertyat(pod, :spec, :containers, :name) == [true, true] + # …and an out-of-range index is absent, not an error + @test Kuber.getpropertyat(pod, :spec, :containers, 9, :name) === nothing + @test !Kuber.haspropertyat(pod, :spec, :containers, 9) + + # raw JSON works too, since put! accepts dicts and callers mix the two + raw = JSON.parse("""{"metadata": {"name": "d"}, "items": [{"a": 1}]}""") + @test Kuber.getpropertyat(raw, :metadata, :name) == "d" + @test Kuber.getpropertyat(raw, :items, 1, :a) == 1 + @test !Kuber.haspropertyat(raw, :metadata, :missing) + + # nothing in, nothing out — a walk never throws on a short path + @test Kuber.getpropertyat(nothing, :a, :b) === nothing + @test !Kuber.haspropertyat(nothing, :a) + @test Kuber.getpropertyat(pod) === pod + end + + @testset "KuberException from ApiError" begin + status = JSON.json(Dict("kind" => "Status", "apiVersion" => "v1", "status" => "Failure", + "message" => "pods \"nope\" not found", "reason" => "NotFound", "code" => 404)) + err = Runtime.ApiError("readCoreV1NamespacedPod", 404, Pair{String,String}[], + Dict{String,Any}(), Vector{UInt8}(status), nothing, nothing) + e = KuberException(err) + # the Status body overrides both message and code + @test e.code == 404 + @test e.message == "pods \"nope\" not found" + @test e.status isa R.KIND_TYPES[("v1", "Status")] + @test e.response === err + @test occursin("not found", sprint(showerror, e)) + + # a non-Status body is kept verbatim, and the HTTP status stands + plain = Runtime.ApiError("readCoreV1NamespacedPod", 503, Pair{String,String}[], + Dict{String,Any}(), Vector{UInt8}("upstream boom"), nothing, nothing) + e2 = KuberException(plain) + @test e2.code == 503 + @test e2.message == "upstream boom" + @test e2.status === nothing + + empty = Runtime.ApiError("readCoreV1NamespacedPod", 500, Pair{String,String}[], + Dict{String,Any}(), UInt8[], nothing, nothing) + @test KuberException(empty).message == "HTTP 500 in readCoreV1NamespacedPod" + end + + @testset "retry classification" begin + retryable(e) = Kuber.k8s_retry_cond(nothing, e)[2] + api(status) = Runtime.ApiError("op", status, Pair{String,String}[], Dict{String,Any}(), UInt8[], nothing, nothing) + + @test retryable(api(503)) + @test retryable(api(500)) + @test retryable(api(504)) + @test !retryable(api(404)) + @test !retryable(api(409)) + @test !retryable(api(401)) + + @test retryable(KuberException(503, "boom", nothing, nothing)) + @test !retryable(KuberException(404, "gone", nothing, nothing)) + + # transport failures: HTTP.jl exceptions now, not is_request_interrupted + @test retryable(HTTP.ConnectError("127.0.0.1:1", ErrorException("refused"))) + @test retryable(HTTP.DNSError("nosuchhost", ErrorException("nxdomain"))) + @test retryable(HTTP.TimeoutError("read", 5_000_000_000)) + @test retryable(Base.IOError("connection reset by peer", -104)) + @test retryable(EOFError()) + # …but not the ones that are decisions rather than accidents + @test !retryable(HTTP.CanceledError("cancelled")) + @test !retryable(HTTP.AddressInUseError("127.0.0.1:8801")) + @test !retryable(ErrorException("something else")) + # a truncated watch stream is handled by the watch loop, not here + @test !retryable(Runtime.DecodeError("streaming response ended with a truncated item")) + + # and it actually retries. `max_tries` counts *attempts*, so the call is + # made exactly that many times. It counted retries until G20, which is + # why a mutating call — pinned to a count of 1 — used to be retried. + tries = 0 + try + Kuber.k8s_retry(; max_tries = 3, tps = 100) do + tries += 1 + throw(api(503)) + end + catch + end + @test tries == 3 + + tries = 0 + try + Kuber.k8s_retry(; max_tries = 3, tps = 100) do + tries += 1 + throw(api(404)) + end + catch + end + @test tries == 1 + end + + @testset "is_retryable is the public face of that classification" begin + # Consumers used OpenAPI.Clients.is_request_interrupted, which OpenAPI.jl + # 1.0 does not have. This is the supported replacement, so it is pinned + # as public behaviour rather than left as an internal detail. + @test is_retryable(KuberException(503, "boom", nothing, nothing)) + @test is_retryable(HTTP.ConnectError("127.0.0.1:1", ErrorException("refused"))) + @test !is_retryable(KuberException(404, "gone", nothing, nothing)) + @test !is_retryable(HTTP.CanceledError("cancelled")) + @test !is_retryable(ErrorException("something else")) + @test !is_retryable(Runtime.DecodeError("truncated")) + + # It has to work on what `watch` actually throws: @sync wraps a failed + # task's exception in a TaskFailedException, inside a CompositeException. + function failed_task(e) + t = @task throw(e) + schedule(t) + try + wait(t) + catch ex + return ex # a TaskFailedException + end + end + wrapped = failed_task(KuberException(503, "boom", nothing, nothing)) + @test wrapped isa TaskFailedException + @test is_retryable(wrapped) + @test is_retryable(CompositeException([wrapped])) + @test !is_retryable(failed_task(KuberException(404, "gone", nothing, nothing))) + + # two independent failures have no single cause to classify + @test !is_retryable(CompositeException([wrapped, wrapped])) + end + + @testset "watch-stream failures are recoverable" begin + # The watch pump re-establishes when the raw channel dies with either a + # DecodeError (a truncated item) or anything k8s_retry_cond accepts. The + # case that matters is a connection aborted mid-chunk — an apiserver + # restart or network drop — which HTTP.jl reports as a ParseError. Before + # this was classified as recoverable the pump rethrew it and the watch + # died, which is precisely what Kuber #68 is about. + recoverable(e) = e isa Runtime.DecodeError || Kuber.k8s_retry_cond(nothing, e)[2] + + @test recoverable(HTTP.ParseError("unexpected EOF while reading HTTP/1 data")) + @test recoverable(Runtime.DecodeError("streaming response ended with a truncated item")) + @test recoverable(HTTP.ConnectError("127.0.0.1:8801", ErrorException("refused"))) + @test recoverable(EOFError()) + # but a deliberate cancellation is not a failure to recover from + @test !recoverable(HTTP.CanceledError("cancelled")) + end + + @testset "request options and timeouts" begin + ctx = KuberContext() + @test get_request_options(ctx) == NamedTuple() + @test get_timeout(ctx) === nothing + + set_timeout(ctx, 30) + @test get_timeout(ctx) == 30 + # every call carries retry=false: HTTP.jl's own retry layer would + # otherwise sit underneath k8s_retry and multiply the request count (G20) + @test Kuber._call_options(ctx) == (retry = false, request_timeout = 30) + # a watch has no overall deadline, but keeps the other options + @test Kuber._call_options(ctx; watch = true) == (retry = false,) + set_request_options(ctx; connect_timeout = 5) + @test Kuber._call_options(ctx; watch = true) == (retry = false, connect_timeout = 5) + # …and a caller who wants HTTP.jl's layer back can say so + set_request_options(ctx; retry = true) + @test Kuber._call_options(ctx).retry === true + set_request_options(ctx; retry = false) + @test get_timeout(ctx) == 30 + + with_timeout(ctx, 10) do c + @test get_timeout(c) == 10 + end + @test get_timeout(ctx) == 30 + + # and it restores on error + @test_throws ErrorException with_timeout(ctx, 10) do c + error("boom") + end + @test get_timeout(ctx) == 30 + + wctx = Kuber.KuberWatchContext(ctx, Kuber.KuberEventStream(1)) + @test get_timeout(wctx) == 30 + with_timeout(wctx, 10) do w + @test get_timeout(w) == 10 + end + @test get_timeout(wctx) == 30 + end + + @testset "api_group naming is unchanged" begin + @test Kuber.api_group("apiregistration.k8s.io") == "Apiregistration" + @test Kuber.api_group("karpenter.sh") == "KarpenterSh" + @test Kuber.api_group("apps") == "Apps" + @test Kuber.api_group("rbac.authorization.k8s.io") == "RbacAuthorization" + end + + @testset "override_pref" begin + @test Kuber.override_pref("apps", "v1", nothing) == "v1" + @test Kuber.override_pref("apps", "v1", ("apps" => "v1beta2",)) == "v1beta2" + @test Kuber.override_pref("batch", "v1", ("apps" => "v1beta2",)) == "v1" + end + + @testset "KuberEvent" begin + pod = kuber_obj(POD_JSON) + ev = KuberEvent("ADDED", pod) + @test ev.type == "ADDED" # not `type_`, unlike the generated model + @test ev.object === pod + @test occursin("ADDED", sprint(show, ev)) + end +end diff --git a/test/register.jl b/test/register.jl new file mode 100644 index 00000000..81f2e9ba --- /dev/null +++ b/test/register.jl @@ -0,0 +1,292 @@ +# Offline checks on `Kuber.register!`: the plug point that replaces 0.2.x's +# `KuberContext(apimodule)` for generated layers Kuber does not ship. +# +# The fixture is a hand-written stand-in for a generated group module — the +# registry only needs a `Client`, model types and operation functions, so nothing +# here needs a spec or a server. Every registration made in this file is undone +# in a `finally`: the tables are process-global, and test/registry.jl asserts +# invariants over all of them, so residue left behind would fail that suite +# depending on which ran first. +using Kuber, Test + +const R = Kuber.ApiImpl + +module FakeGroups + +# stands in for one generated group module +module MetricsFakeV1 + struct Client + server::String + Client(server::String; kwargs...) = new(server) + end + struct NodeStat + kind::String + end + struct NodeStatList + kind::String + end + struct Pod # a kind name core already serves, on purpose + kind::String + end + listfakev1nodestat(client; kwargs...) = nothing + readfakev1nodestat(client, name::String; kwargs...) = nothing + watchfakev1nodestat(client; kwargs...) = nothing # never registrable +end + +# a second module, to collide with the first +module OtherFakeV1 + struct Client + server::String + Client(server::String; kwargs...) = new(server) + end + struct NodeStat + kind::String + end +end + +const GV = "fake.kuber.test/v1" + +const GROUP_MODULES = Dict{String,Module}(GV => MetricsFakeV1) +const MODULE_GVS = Dict{Module,String}(MetricsFakeV1 => GV) +const KIND_TYPES = Dict{Tuple{String,String},Type}( + (GV, "NodeStat") => MetricsFakeV1.NodeStat, + (GV, "NodeStatList") => MetricsFakeV1.NodeStatList, + (GV, "Pod") => MetricsFakeV1.Pod, +) +const OPS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (MetricsFakeV1, :list, :NodeStat, :cluster) => MetricsFakeV1.listfakev1nodestat, + (MetricsFakeV1, :get, :NodeStat, :cluster) => MetricsFakeV1.readfakev1nodestat, +) +const OP_PARAMS = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (MetricsFakeV1, :list, :NodeStat, :cluster) => Symbol[], + (MetricsFakeV1, :get, :NodeStat, :cluster) => [:name], +) +const OP_BODIES = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}() + +"""The six tables as keyword arguments, so a test can perturb one of them.""" +tables(; kwargs...) = merge(( + group_modules = copy(GROUP_MODULES), + module_gvs = copy(MODULE_GVS), + kind_types = copy(KIND_TYPES), + ops = copy(OPS), + op_params = copy(OP_PARAMS), + op_bodies = copy(OP_BODIES), + ), NamedTuple(kwargs)) + +end # module FakeGroups + +module NotARegistry end + +const FAKE = FakeGroups.MetricsFakeV1 +const FAKE_GV = FakeGroups.GV + +"""Run `f()` with the fixture registered, and unregister it whatever happens.""" +function with_fake(f) + mods = Kuber.register!(FakeGroups) + try + f(mods) + finally + Kuber.unregister!(FakeGroups) + end +end + +@testset "register!" begin + # snapshot the shipped tables, so every testset can assert it left no residue + shipped = ( + length(R.GROUP_MODULES), length(R.MODULE_GVS), length(R.KIND_TYPES), + length(R.OPS), length(R.OP_PARAMS), length(R.OP_BODIES), + ) + sizes() = ( + length(R.GROUP_MODULES), length(R.MODULE_GVS), length(R.KIND_TYPES), + length(R.OPS), length(R.OP_PARAMS), length(R.OP_BODIES), + ) + + @testset "a registry module merges into the tables" begin + with_fake() do mods + @test mods == [FAKE] + @test R.GROUP_MODULES[FAKE_GV] === FAKE + @test R.MODULE_GVS[FAKE] == FAKE_GV + @test R.KIND_TYPES[(FAKE_GV, "NodeStat")] === FAKE.NodeStat + @test R.OPS[(FAKE, :list, :NodeStat, :cluster)] === FAKE.listfakev1nodestat + @test R.OP_PARAMS[(FAKE, :get, :NodeStat, :cluster)] == [:name] + # nothing shipped was displaced + @test parentmodule(R.KIND_TYPES[("v1", "Pod")]) === R.GROUP_MODULES["v1"] + @test haskey(R.OPS, (R.GROUP_MODULES["v1"], :list, :Pod, :namespaced)) + end + @test sizes() == shipped + @test !haskey(R.GROUP_MODULES, FAKE_GV) + end + + @testset "the verb layer resolves registered kinds" begin + with_fake() do _ + ctx = KuberContext() + ctx.initialized = true # pretend discovery ran + + # by explicit apiversion, with no discovery involved at all + @test Kuber._resolve_module(ctx, :NodeStat, FAKE_GV) === FAKE + @test kind_to_type(ctx, :NodeStat, FAKE_GV) === FAKE.NodeStat + key, f, params, scope = Kuber._find_op(FAKE, :get, :NodeStat, "default") + @test f === FAKE.readfakev1nodestat + @test params == [:name] + @test scope === :cluster # falls back past :namespaced, as before + + # and through discovery, once the group is in ctx.apis + ctx.apis[:Core] = [R.GROUP_MODULES["v1"]] + ctx.apis[:FakeKuberTest] = [FAKE] + Kuber.build_model_api_map(ctx) + @test ctx.modelapi[:NodeStat] === FAKE + @test Kuber._resolve_module(ctx, :NodeStat, nothing) === FAKE + # a kind name two groups declare goes to core, by build order rather + # than registration order — apiversion= is the way to be explicit + @test ctx.modelapi[:Pod] === R.GROUP_MODULES["v1"] + @test Kuber._resolve_module(ctx, :Pod, FAKE_GV) === FAKE + end + @test sizes() == shipped + end + + @testset "registering the same content twice is a no-op" begin + with_fake() do _ + n = sizes() + @test Kuber.register!(FakeGroups) == [FAKE] + @test sizes() == n + end + @test sizes() == shipped + end + + @testset "conflicts are refused" begin + with_fake() do _ + # another module claiming the group version + other = FakeGroups.OtherFakeV1 + @test_throws ArgumentError Kuber.register!(; + group_modules = Dict{String,Module}(FAKE_GV => other), + module_gvs = Dict{Module,String}(other => FAKE_GV), + kind_types = Dict{Tuple{String,String},Type}((FAKE_GV, "NodeStat") => other.NodeStat), + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}(), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}(), + ) + @test R.GROUP_MODULES[FAKE_GV] === FAKE + + # the same module claiming a second group version + @test_throws ArgumentError Kuber.register!(; + group_modules = Dict{String,Module}("fake.kuber.test/v2" => FAKE), + module_gvs = Dict{Module,String}(FAKE => "fake.kuber.test/v2"), + kind_types = Dict{Tuple{String,String},Type}(), + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}(), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}(), + ) + @test !haskey(R.GROUP_MODULES, "fake.kuber.test/v2") + end + # a shipped group version cannot be taken over either + @test_throws ArgumentError Kuber.register!(; + group_modules = Dict{String,Module}("v1" => FAKE), + module_gvs = Dict{Module,String}(FAKE => "v1"), + kind_types = Dict{Tuple{String,String},Type}(), + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}(), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}(), + ) + @test R.GROUP_MODULES["v1"] !== FAKE + @test sizes() == shipped + end + + @testset "malformed tables are refused before anything is merged" begin + T = FakeGroups + bad = [ + # not a registry module at all + () -> Kuber.register!(NotARegistry), + # MODULE_GVS is not the inverse + () -> Kuber.register!(; T.tables(module_gvs = Dict{Module,String}(FAKE => "other/v1"))...), + () -> Kuber.register!(; T.tables(module_gvs = Dict{Module,String}())...), + # the group module has no Client + () -> Kuber.register!(; T.tables( + group_modules = Dict{String,Module}(FAKE_GV => NotARegistry), + module_gvs = Dict{Module,String}(NotARegistry => FAKE_GV))...), + # a kind in a group version that is not being registered + () -> Kuber.register!(; T.tables(kind_types = Dict{Tuple{String,String},Type}( + ("elsewhere/v1", "NodeStat") => FAKE.NodeStat))...), + # a type that lives in another module + () -> Kuber.register!(; T.tables(kind_types = Dict{Tuple{String,String},Type}( + (FAKE_GV, "NodeStat") => FakeGroups.OtherFakeV1.NodeStat))...), + # an operation without its positional argument names + () -> Kuber.register!(; T.tables( + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}())...), + # an unknown verb, and an unknown scope + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :frobnicate, :NodeStat, :cluster) => FAKE.listfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :frobnicate, :NodeStat, :cluster) => Symbol[]))...), + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :list, :NodeStat, :everywhere) => FAKE.listfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :list, :NodeStat, :everywhere) => Symbol[]))...), + # a deprecated /watch/ operation + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :list, :NodeStat, :cluster) => FAKE.watchfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :list, :NodeStat, :cluster) => Symbol[]))...), + # a namespaced operation whose positional arguments skip the namespace + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :get, :NodeStat, :namespaced) => FAKE.readfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :get, :NodeStat, :namespaced) => [:name]))...), + # a cluster-scoped operation that takes one anyway + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :get, :NodeStat, :cluster) => FAKE.readfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :get, :NodeStat, :cluster) => [:namespace, :name]))...), + # a body that is not the last positional argument, and a verb that + # sends no body at all + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :create, :NodeStat, :cluster) => FAKE.readfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :create, :NodeStat, :cluster) => [:body, :name]))...), + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :delete, :NodeStat, :cluster) => FAKE.readfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :delete, :NodeStat, :cluster) => [:name, :body]))...), + # a body for an operation that is not registered + () -> Kuber.register!(; T.tables( + op_bodies = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}( + (FAKE, :create, :NodeStat, :cluster) => + Dict{String,Type}("application/json" => FAKE.NodeStat)))...), + # …and a body entry naming no media type at all + () -> Kuber.register!(; T.tables( + ops = Dict{Tuple{Module,Symbol,Symbol,Symbol},Function}( + (FAKE, :create, :NodeStat, :cluster) => FAKE.readfakev1nodestat), + op_params = Dict{Tuple{Module,Symbol,Symbol,Symbol},Vector{Symbol}}( + (FAKE, :create, :NodeStat, :cluster) => [:body]), + op_bodies = Dict{Tuple{Module,Symbol,Symbol,Symbol},Dict{String,Type}}( + (FAKE, :create, :NodeStat, :cluster) => Dict{String,Type}()))...), + ] + for f in bad + @test_throws ArgumentError f() + end + @test sizes() == shipped # every rejection was atomic + end + + @testset "unregister!" begin + Kuber.register!(FakeGroups) + @test Kuber.unregister!(FAKE) == [FAKE] # by group module + @test sizes() == shipped + @test !haskey(R.MODULE_GVS, FAKE) + @test !any(k -> k[1] == FAKE_GV, keys(R.KIND_TYPES)) + @test !any(k -> k[1] === FAKE, keys(R.OPS)) + + @test Kuber.unregister!(FAKE) == Module[] # idempotent + @test Kuber.unregister!(NotARegistry) == Module[] # and lenient + + Kuber.register!(FakeGroups) + @test Kuber.unregister!(FakeGroups) == [FAKE] # by registry module + @test sizes() == shipped + + # what Kuber ships stays put + @test_throws ArgumentError Kuber.unregister!(R.GROUP_MODULES["v1"]) + @test sizes() == shipped + end +end diff --git a/test/registry.jl b/test/registry.jl new file mode 100644 index 00000000..33d98438 --- /dev/null +++ b/test/registry.jl @@ -0,0 +1,154 @@ +# Offline checks on the generated layer: no cluster needed. +# +# These are the Phase 1 gate of OpenAPIv1TrialBranchPlan.md §6 — the registry +# loads and every entry in it resolves. A failure here means the generation +# pipeline and the emitted tables have drifted apart, which is a regeneration +# problem, never something to patch by hand in src/ApiImpl/generated. +using Kuber, Test + +const R = Kuber.ApiImpl + +@testset "registry" begin + @testset "tables agree" begin + @test length(R.GROUP_MODULES) == length(R.MODULE_GVS) + @test Set(values(R.GROUP_MODULES)) == Set(keys(R.MODULE_GVS)) + for (gv, mod) in R.GROUP_MODULES + @test R.MODULE_GVS[mod] == gv + end + @test keys(R.OPS) == keys(R.OP_PARAMS) + end + + @testset "every kind resolves to a type in a shipped module" begin + for ((apiversion, kind), T) in R.KIND_TYPES + @test T isa Type + @test haskey(R.MODULE_GVS, parentmodule(T)) + @test haskey(R.GROUP_MODULES, apiversion) + end + end + + @testset "every op resolves to a function in its own module" begin + for (key, f) in R.OPS + mod, verb, kind, scope = key + @test f isa Function + @test parentmodule(f) === mod + @test verb in (:get, :list, :create, :replace, :patch, :delete, :deletecollection) + @test scope in (:namespaced, :cluster, :allns) + end + end + + @testset "request bodies name a type per media type" begin + # Since patch_k8s_spec.jq §6 a PATCH does not have one body type: four of + # its media types take the `Patch` object model and json-patch takes the + # `JSONPatch` array. The rule has to hold for every patchable kind in + # every module, which is what this asserts — a document where it silently + # did not apply would leave json-patch callers broken again. + patchmedia = Set([ + "application/apply-patch+cbor", "application/apply-patch+yaml", + "application/json-patch+json", "application/merge-patch+json", + "application/strategic-merge-patch+json", + ]) + npatch = 0 + for (key, media) in R.OP_BODIES + mod, verb, kind, scope = key + @test haskey(R.OPS, key) + @test !isempty(media) + for (m, T) in media + @test m isa String + @test T isa Type + end + if verb === :patch + npatch += 1 + @test Set(keys(media)) == patchmedia + jsonpatch = media["application/json-patch+json"] + @test jsonpatch <: AbstractVector + @test parentmodule(eltype(jsonpatch)) === mod + # the other four stay the open-object Patch model + @test media["application/merge-patch+json"] === media["application/apply-patch+yaml"] + @test !(media["application/merge-patch+json"] <: AbstractVector) + else + @test collect(keys(media)) == ["application/json"] + end + end + @test npatch > 0 + end + + @testset "no watch operations leak in" begin + # Trap 8: the middle path does not patch the deprecated /watch/ paths, + # so nothing may reference a watch* operationId. Watching is + # `watch=true` on the list op plus an accept-scoped codec. + @test !any(startswith(String(nameof(f)), "watch") for f in values(R.OPS)) + end + + @testset "positional params are path order, body last" begin + for (key, params) in R.OP_PARAMS + mod, verb, kind, scope = key + if scope === :namespaced + @test first(params) === :namespace + else + @test :namespace ∉ params + end + if :body in params + @test last(params) === :body + @test verb in (:create, :replace, :patch) + end + @test allunique(params) + end + end + + @testset "spot checks" begin + core = R.GROUP_MODULES["v1"] + apps = R.GROUP_MODULES["apps/v1"] + @test R.KIND_TYPES[("v1", "Pod")] === core.IoK8sApiCoreV1Pod + @test R.KIND_TYPES[("v1", "PodList")] === core.IoK8sApiCoreV1PodList + @test R.KIND_TYPES[("apps/v1", "Deployment")] === apps.IoK8sApiAppsV1Deployment + @test R.OPS[(core, :list, :Pod, :namespaced)] === core.listcorev1namespacedpod + @test R.OPS[(core, :list, :Pod, :allns)] === core.listcorev1podforallnamespaces + @test R.OPS[(core, :get, :Pod, :namespaced)] === core.readcorev1namespacedpod + @test R.OP_PARAMS[(core, :get, :Pod, :namespaced)] == [:namespace, :name] + # cluster-scoped resources take the name alone + @test R.OP_PARAMS[(core, :get, :Namespace, :cluster)] == [:name] + # subresources get a synthetic kind off the parent resource's path, which + # is how :PodLog (§5.4) reaches the table through the generic path + @test R.OPS[(core, :get, :PodLog, :namespaced)] === core.readcorev1namespacedpodlog + @test R.OPS[(core, :get, :PodStatus, :namespaced)] === core.readcorev1namespacedpodstatus + # two shipped versions of one kind — why OPS is keyed by module + @test R.OPS[(R.GROUP_MODULES["autoscaling/v1"], :list, :HorizontalPodAutoscaler, :allns)] !== + R.OPS[(R.GROUP_MODULES["autoscaling/v2"], :list, :HorizontalPodAutoscaler, :allns)] + end + + @testset "referenced schemas are one type, not a copy per use site" begin + # The gate on patch rule §7. k8s wraps every property `$ref` in a + # single-element `allOf` so it can hang a description beside it; read + # literally that is a new schema, and the generator mints a type per use + # site — `Pod.spec` became `…PodSpec2`, every kind got its own + # `…Metadata`, and `PodList.items` its own element type, which is what + # made `item isa kind_to_type(ctx, :Pod)` false (G18). + # + # Asserted as type *identity* rather than by counting types: a collapse + # that produced an alias per use site would shrink the diff and still be + # wrong. + modelfield(T, f) = only(filter(t -> t !== Nothing && !(t <: Kuber.Runtime.Absent), + Base.uniontypes(fieldtype(T, f)))) + + for (gv, kind, spectype) in (("v1", "Pod", :IoK8sApiCoreV1PodSpec), + ("v1", "Service", :IoK8sApiCoreV1ServiceSpec), + ("apps/v1", "Deployment", :IoK8sApiAppsV1DeploymentSpec), + ("batch/v1", "Job", :IoK8sApiBatchV1JobSpec)) + T = R.KIND_TYPES[(gv, kind)] + mod = parentmodule(T) + # the kind's own spec is the group's spec type, not a positional copy + @test modelfield(T, :spec) === getfield(mod, spectype) + # …and its metadata is the shared ObjectMeta of that module + @test modelfield(T, :metadata) === + getfield(mod, :IoK8sApimachineryPkgApisMetaV1ObjectMeta) + # a list's items are the kind itself — the G18 assertion + LT = R.KIND_TYPES[(gv, kind * "List")] + @test eltype(modelfield(LT, :items)) === T + end + + # nothing named after its position survives in any module + for mod in values(R.GROUP_MODULES) + @test isempty(filter(n -> occursin("ListItemsItem", String(n)), names(mod; all = true))) + end + end +end diff --git a/test/retries.jl b/test/retries.jl new file mode 100644 index 00000000..c57e820a --- /dev/null +++ b/test/retries.jl @@ -0,0 +1,210 @@ +# Retry behaviour against injected failures — G14 in OpenAPIv1ConsumerGaps.md. +# +# `k8s_retry_cond` was characterized offline by test/characterize_retries.jl, +# which pins the *exception types* the runtime raises but is not part of +# runtests.jl and never drives the retry loop. This file drives the loop: a +# server that always fails with a chosen status, and a request counter, so +# "retried" is the difference between one request and several and is asserted +# as such rather than inferred. +# +# Offline and deterministic — no cluster involved. +using Kuber, HTTP, JSON, Test + +const RETRY_CORE = Kuber.ApiImpl.GROUP_MODULES["v1"] + +""" + failing_api(status) -> (url, count, stop) + +A server that answers every request with `status` and a k8s `Status` body. +`count[]` is the number of requests it saw. +""" +function failing_api(status::Int) + count = Ref(0) + lck = ReentrantLock() + body = JSON.json(Dict("kind" => "Status", "apiVersion" => "v1", "status" => "Failure", + "code" => status, "reason" => "Injected", + "message" => "injected $status")) + server = HTTP.listen!("127.0.0.1", 0; listenany = true) do http + lock(() -> (count[] += 1), lck) + HTTP.setstatus(http, status) + HTTP.setheader(http, "Content-Type" => "application/json") + # k8s sheds load with 429 plus Retry-After; sent so the fixture matches + # what a real apiserver does under priority-and-fairness + status == 429 && HTTP.setheader(http, "Retry-After" => "1") + HTTP.setheader(http, "Content-Length" => string(sizeof(body))) + HTTP.startwrite(http) + write(http, body) + end + return "http://127.0.0.1:$(HTTP.port(server))", count, () -> close(server) +end + +""" + retryctx(url; httpretry=false) -> KuberContext + +Discovery pre-seeded. `_call_options` sets `retry=false` on every call by +default (G20), so the request count measures Kuber's retry loop alone unless a +test asks otherwise — see the last testset for what HTTP.jl's layer does when it +is put back. +""" +function retryctx(url; httpretry::Bool = false) + ctx = KuberContext() + set_server(ctx, url) + set_ns(ctx, "default") + ctx.apis[:Core] = [RETRY_CORE] + ctx.modelapi[:Pod] = RETRY_CORE + ctx.initialized = true + httpretry && Kuber.set_request_options(ctx; retry = true) + return ctx +end + +function failed_list(ctx; kwargs...) + try + list(ctx, :Pod; kwargs...) + return nothing + catch e + return e + end +end + +@testset "retries" begin + @testset "a retryable status is retried, a decision is not" begin + # 500/502/503/504 are what a busy or restarting apiserver produces and + # are worth riding out. 404/409/422 are answers: retrying them turns a + # fast "no" into a slow one, and 409 is what a create against an + # existing object returns. + for (status, retried) in ((500, true), (502, true), (503, true), (504, true), + (404, false), (409, false), (422, false)) + url, count, stop = failing_api(status) + err = failed_list(retryctx(url); max_tries = 3) + @test err isa KuberException + @test err.code == status + @test Kuber.is_retryable(err) == retried + # `max_tries` is a count of attempts, so a retried call makes + # exactly that many requests + @test count[] == (retried ? 3 : 1) + stop() + end + end + + @testset "max_tries counts attempts" begin + # It counted *retries* until G20: k8s_delay passed max_tries straight + # through as ExponentialBackOff's `n`, and Base.retry does n retries on + # top of the first attempt, so max_tries=1 was two requests. That also + # meant a mutating call — pinned to retries(ctx, true) == 1 — was + # retried once, despite set_retries(all_apis=false) meaning it must not + # be. master computes the delays the same way and has the same bug. + for (tries, requests) in ((0, 1), (1, 1), (2, 2), (3, 3), (5, 5)) + url, count, stop = failing_api(503) + failed_list(retryctx(url); max_tries = tries) + @test count[] == requests + stop() + end + end + + @testset "a mutating call is not retried" begin + # The contract set_retries documents: all_apis=false means put! and + # friends get one attempt. Before G20 they got two, because max_tries=1 + # meant "one retry". Asserted through `retries` rather than through a + # live put! so it pins the budget rather than one verb's behaviour. + ctx = retryctx("http://127.0.0.1:1") + @test Kuber.retries(ctx, true) == 1 + @test Kuber.retries(ctx, false) == 5 + url, count, stop = failing_api(503) + failed_list(retryctx(url); max_tries = Kuber.retries(ctx, true)) + @test count[] == 1 + stop() + end + + @testset "429 is retried, and Retry-After is honoured" begin + # G19. Kubernetes' priority-and-fairness layer sheds load with 429 plus + # Retry-After, and client-go retries it; k8s_retryable_codes omitted it + # until now — on master it still does — so a throttled call failed at + # once where client-go would have absorbed it. + url, count, stop = failing_api(429) + err = failed_list(retryctx(url); max_tries = 3) + @test err isa KuberException + @test err.code == 429 + @test Kuber.is_retryable(err) + @test count[] == 3 + stop() + + # The fixture sends `Retry-After: 1`, which is longer than the backoff + # would wait on its own (first delay is 1/tps = 0.5 s), so honouring it + # is observable as elapsed time. Two retries at >= 1 s each. + url, count, stop = failing_api(429) + elapsed = @elapsed failed_list(retryctx(url); max_tries = 3) + @test count[] == 3 + @test elapsed >= 2.0 + stop() + + # …and it only applies to 429: a 503 carrying the same header would be + # paced by the backoff instead, which is why _retry_after checks the code + @test Kuber._retry_after(KuberException(503, "x", nothing, nothing)) == 0.0 + @test Kuber._retry_after(KuberException(429, "x", nothing, nothing)) == 0.0 + end + + @testset "a watch establish failure is retried" begin + # The establish call is the only thing in the watch path k8s_retry wraps: + # once the response head arrives the call has returned, so nothing after + # that is a retry (see k8s_retry_cond's docstring). + url, count, stop = failing_api(503) + ctx = retryctx(url) + stream = Kuber.KuberEventStream(4) + wctx = Kuber.KuberWatchContext(ctx, stream) + # resource_version skips the initial list, so every request here is a + # watch establish + watcher = @async list(wctx, :Pod; watch = true, push_initial = false, + resource_version = "1", max_tries = 3) + @test timedwait(() -> istaskdone(watcher), 90.0) == :ok + @test count[] == 3 + @test istaskfailed(watcher) + @test Kuber.is_retryable(watcher.result) + close(stream) + stop() + end + + @testset "HTTP.jl's retry layer is off, and multiplies the count when on" begin + # G20. Kuber's loop was not the only one: HTTP.jl 2.x retries idempotent + # requests on a retryable status by default, so each Kuber attempt cost + # several requests, `max_tries` bounded none of them, and a mutating call + # could be retried by a layer with no notion of mutating. A KuberContext + # now sets retry=false, so Kuber owns it. + url, count, stop = failing_api(503) + failed_list(retryctx(url); max_tries = 1) + @test count[] == 1 # the default: Kuber alone + stop() + + # …and handing it back still works, for anyone who wants it. Asserted as + # a multiplier rather than an exact count: the factor is HTTP.jl's + # default, not Kuber's contract. + url, count, stop = failing_api(503) + failed_list(retryctx(url; httpretry = true); max_tries = 1) + @test count[] > 1 + stop() + end + + @testset "is_retryable classifies what consumers will hand it" begin + # C2/G15's helper, over the shapes a consumer actually catches. + @test Kuber.is_retryable(KuberException(503, "unavailable", nothing, nothing)) + @test !Kuber.is_retryable(KuberException(404, "not found", nothing, nothing)) + + # a failure raised inside a task, which is how `watch` reports one + wrapped = try + @sync @async throw(KuberException(503, "unavailable", nothing, nothing)) + catch e + e + end + @test wrapped isa CompositeException + @test Kuber.is_retryable(wrapped) + + # …and a transport failure, which carries no status at all + transport = try + HTTP.get("http://127.0.0.1:1"; retry = false, connect_timeout = 5) + nothing + catch e + e + end + @test transport !== nothing + @test Kuber.is_retryable(transport) + end +end diff --git a/test/runtests.jl b/test/runtests.jl index adebc9ca..b5e5986b 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,49 +1,80 @@ using Kuber -using OpenAPI +using JSON +using Base64 using Test -const Typedefs = Kuber.ApiImpl.Typedefs -const Kubernetes = Kuber.ApiImpl.Kubernetes +# The offline suites (Phase 1/2/3 gates of OpenAPIv1TrialBranchPlan.md §6) need +# no cluster and run first, so a broken registry or a broken verb layer is +# reported before anything touches the network. +include("registry.jl") +include("register.jl") +include("helpers.jl") +include("simpleapi.jl") +# Retries drive a fake apiserver that always fails, so they are offline too. +include("retries.jl") -#On GCE: -#- Bring up a Kubernetes cluster: https://cloud.google.com/container-engine/docs/clusters/operations -# - `gcloud container clusters create cluster1 --num-nodes=2 --zone=us-central1-a --machine-type=n1-standard-1 --image-type=container_vm` -# - Note: set image-type to container_vm as the v1.4.0 Google container vm does not have glusterfs client. See: https://groups.google.com/forum/#!topic/kubernetes-users/USCSQ9TZThY -#- Enable access to the cluster: -# - Get kubernetes credentials: `gcloud container clusters get-credentials cluster1 --zone us-central1-a` -# - See credentials: `gcloud container clusters describe cluster-1 --zone us-central1-a` -# - Start kubectl in proxy mode -# - run `kubectl proxy` +# Watch recovery runs against a fake apiserver, so it is offline too. It waits on +# real timing (a first event that has to compile the whole decode path, then +# several re-establishments), which costs about half a minute, and it covers the +# watch acceptance criteria nothing else does — stop, re-watch, truncation, +# expiry, backoff. On by default; set KUBER_SKIP_WATCH_RECOVERY=1 to skip it. +if get(ENV, "KUBER_SKIP_WATCH_RECOVERY", "0") == "1" + @warn "skipping test/watch_recovery.jl (KUBER_SKIP_WATCH_RECOVERY=1)" +else + include("watch_recovery.jl") +end + +# The rest is an integration suite: it creates and deletes real objects against a +# live API server. Point it at a `kubectl proxy` (CI uses kind + kubectl proxy; +# local runs used k3s v1.35.4 on port 8801). +const SERVER = get(ENV, "KUBER_TEST_SERVER", "http://localhost:8001") + +const REGISTRY = Kuber.ApiImpl + +function server_reachable(server) + try + ctx = KuberContext() + set_server(ctx, server) + Kuber._discovery_get(ctx, "/api"; max_tries = 1) + return true + catch + return false + end +end -function init_context(override=nothing, verbose=true) +function init_context(override = nothing, verbose = true) ctx = KuberContext() - set_server(ctx, "http://localhost:8001") + set_server(ctx, SERVER) set_ns(ctx, "default") - set_retries(ctx; count=3, all_apis=false) - Kuber.set_api_versions!(ctx; override=override, verbose=verbose) - httplib_name = ctx.httplib === nothing ? "http (default)" : string(ctx.httplib) - @info("KuberContext preferred HTTP library: $httplib_name") - if hasproperty(ctx.client, :httplib) - @info("OpenAPI client using HTTP library: $(ctx.client.httplib)") - end + set_retries(ctx; count = 3, all_apis = false) + Kuber.set_api_versions!(ctx; override = override, verbose = verbose) ctx end -function test_set_timeout(ctx) - @test Kuber.get_timeout(ctx) == OpenAPI.Clients.DEFAULT_TIMEOUT_SECS +function test_request_options(ctx) + # Timeouts moved from the 0.2.x client's mutable `timeout[]` to HTTP.jl 2.x + # request options on the context, so there is no DEFAULT_TIMEOUT_SECS to + # compare against: unset means "no deadline". + @test Kuber.get_timeout(ctx) === nothing Kuber.with_timeout(ctx, 10) do ctx @test Kuber.get_timeout(ctx) == 10 end + @test Kuber.get_timeout(ctx) === nothing - wctx = Kuber.KuberWatchContext(ctx, Channel{Any}()) - @test Kuber.get_timeout(wctx) == OpenAPI.Clients.DEFAULT_TIMEOUT_SECS + wctx = Kuber.KuberWatchContext(ctx, Channel{Any}(1)) + @test Kuber.get_timeout(wctx) === nothing Kuber.with_timeout(wctx, 10) do wctx @test Kuber.get_timeout(wctx) == 10 + # a watch never carries an overall deadline, but keeps the other options + @test !haskey(Kuber._call_options(wctx; watch = true), :request_timeout) end - @test Kuber.get_timeout(wctx) == OpenAPI.Clients.DEFAULT_TIMEOUT_SECS + @test Kuber.get_timeout(wctx) === nothing - @test Kuber.get_timeout(ctx) == OpenAPI.Clients.DEFAULT_TIMEOUT_SECS + # a live call still works with a deadline set + Kuber.with_timeout(ctx, 30) do ctx + @test Kuber.kuber_kind(get(ctx, :Namespace, "default")) == "Namespace" + end end function list_cluster_components(ctx) @@ -94,65 +125,48 @@ function list_namespace_objects(ctx) @test isa(res, Kuber.kind_to_type(ctx, :ReplicationControllerList)) end + @testset "List across all namespaces" begin + res = get(ctx, :Pod; namespace = "*") + @test isa(res, Kuber.kind_to_type(ctx, :PodList)) + end + nothing end function create_versioned_models(ctx) - cron_batchv1beta1 = kuber_obj(ctx, """{ - "kind": "CronJob", - "apiVersion": "batch/v1beta1", - "metadata": { - "name": "hello" - }, + # The old version of this test used batch/v1beta1 and batch/v2alpha1 + # CronJobs; both were removed from Kubernetes long before 1.35, and batch + # now serves v1 alone. autoscaling is the group that still offers one kind + # in two served versions, so it is what exercises versioned typing. + hpa_v1 = kuber_obj("""{ + "kind": "HorizontalPodAutoscaler", + "apiVersion": "autoscaling/v1", + "metadata": {"name": "hello"}, "spec": { - "schedule": "*/1 * * * *", - "jobTemplate": { - "spec": { - "template": { - "spec": { - "containers": [{ - "name": "hello", - "image": "busybox", - "args": ["/bin/sh", "-c", "date"] - }], - "restartPolicy": "OnFailure" - } - } - } - } + "scaleTargetRef": {"kind": "Deployment", "name": "hello"}, + "maxReplicas": 2 } }""") - @test isa(cron_batchv1beta1, Kubernetes.IoK8sApiBatchV1beta1CronJob) + @test isa(hpa_v1, REGISTRY.KIND_TYPES[("autoscaling/v1", "HorizontalPodAutoscaler")]) - cron_batchv2alpha1 = kuber_obj(ctx, """{ - "kind": "CronJob", - "apiVersion": "batch/v2alpha1", - "metadata": { - "name": "hello" - }, + hpa_v2 = kuber_obj("""{ + "kind": "HorizontalPodAutoscaler", + "apiVersion": "autoscaling/v2", + "metadata": {"name": "hello"}, "spec": { - "schedule": "*/1 * * * *", - "jobTemplate": { - "spec": { - "template": { - "spec": { - "containers": [{ - "name": "hello", - "image": "busybox", - "args": ["/bin/sh", "-c", "date"] - }], - "restartPolicy": "OnFailure" - } - } - } - } + "scaleTargetRef": {"kind": "Deployment", "name": "hello"}, + "maxReplicas": 2 } }""") - @test isa(cron_batchv2alpha1, Kubernetes.IoK8sApiBatchV2alpha1CronJob) + @test isa(hpa_v2, REGISTRY.KIND_TYPES[("autoscaling/v2", "HorizontalPodAutoscaler")]) + @test typeof(hpa_v1) !== typeof(hpa_v2) + + # a kind this build does not ship is a clean lookup miss + @test_throws KeyError kuber_obj("""{"kind": "CronJob", "apiVersion": "batch/v1beta1"}""") end function create_delete_job(ctx, testid) - nginx_pod = kuber_obj(ctx, """{ + nginx_pod = kuber_obj("""{ "kind": "Pod", "metadata":{ "name": "nginx-pod$testid", @@ -176,7 +190,7 @@ function create_delete_job(ctx, testid) } }""") - nginx_service = kuber_obj(ctx, """{ + nginx_service = kuber_obj("""{ "kind": "Service", "metadata": { "name": "nginx-service$testid", @@ -189,7 +203,7 @@ function create_delete_job(ctx, testid) } }""") - nginx_rc = kuber_obj(ctx, """{ + nginx_rc = kuber_obj("""{ "kind": "ReplicationController", "metadata": { "name": "nginx-rc$testid", @@ -227,19 +241,41 @@ function create_delete_job(ctx, testid) } }""") - nginx_rc_service = kuber_obj(ctx, """{ - "kind": "Service", - "metadata": { - "name": "nginx-rc-service$testid", - "namespace": "default", - "labels": {"name": "nginx-rc-service$testid"} - }, + job = kuber_obj("""{ + "kind": "Job", + "apiVersion": "batch/v1", + "metadata": {"name": "hello-job$testid"}, "spec": { - "type": "LoadBalancer", - "ports": [ - {"port": 80, "name": "http"} - ], - "selector": {"name": "nginx-pod$testid"} + "template": { + "spec": { + "containers": [{ + "name": "hello$testid", + "image": "busybox", + "args": ["/bin/sh", "-c", "date"] + }], + "restartPolicy": "Never" + } + } + } + }""") + + deployment = kuber_obj("""{ + "kind": "Deployment", + "apiVersion": "apps/v1", + "metadata": {"name": "hello-dep$testid"}, + "spec": { + "replicas": 1, + "selector": {"matchLabels": {"name": "hello-dep$testid"}}, + "template": { + "metadata": {"labels": {"name": "hello-dep$testid"}}, + "spec": { + "containers": [{ + "name": "busybox$testid", + "image": "busybox", + "args": ["sleep", "3600"] + }] + } + } } }""") @@ -247,7 +283,8 @@ function create_delete_job(ctx, testid) @test isa(nginx_pod, Kuber.kind_to_type(ctx, "Pod")) @test isa(nginx_service, Kuber.kind_to_type(ctx, "Service")) @test isa(nginx_rc, Kuber.kind_to_type(ctx, "ReplicationController")) - @test isa(nginx_rc_service, Kuber.kind_to_type(ctx, "Service")) + @test isa(job, Kuber.kind_to_type(ctx, "Job")) + @test isa(deployment, Kuber.kind_to_type(ctx, "Deployment")) end @testset "Create nginx pod" begin @@ -260,24 +297,186 @@ function create_delete_job(ctx, testid) @test isa(res, Kuber.kind_to_type(ctx, :Service)) end + @testset "Create/patch/delete a Job and a Deployment" begin + res = put!(ctx, job) + @test kuber_kind(res) == "Job" + + res = put!(ctx, deployment) + @test kuber_kind(res) == "Deployment" + @test Kuber._field(res.spec.replicas) == 1 + + patched = update!(ctx, :Deployment, "hello-dep$testid", + Dict("spec" => Dict("replicas" => 2)), "application/merge-patch+json") + @test Kuber._field(patched.spec.replicas) == 2 + + # a patch media type k8s does not document is rejected before the call + @test_throws ArgumentError update!(ctx, :Deployment, "hello-dep$testid", + Dict("spec" => Dict()), "application/json") + + # A JSON patch is an ARRAY of RFC 6902 operations, not an object — the + # shape every json-patch caller in JuliaRun and JobLoops uses, and the + # one k8s's own document gets wrong (patch_k8s_spec.jq §6). + patched = update!(ctx, :Deployment, "hello-dep$testid", + [Dict{String,Any}("op" => "replace", "path" => "/spec/replicas", "value" => 3)], + "application/json-patch+json") + @test Kuber._field(patched.spec.replicas) == 3 + + # Two operations in one document, as julia_parallel_scale sends for a + # Job, and with an object as the value, as taint_update_patch does. The + # `add` names /metadata/labels rather than a key inside it: this + # deployment has no labels, and RFC 6902 `add` needs its parent to exist + # — a nested path is a 422 from the apiserver. + patched = update!(ctx, :Deployment, "hello-dep$testid", [ + Dict{String,Any}("op" => "replace", "path" => "/spec/replicas", "value" => 1), + Dict{String,Any}("op" => "add", "path" => "/metadata/labels", + "value" => Dict("patched" => "yes")), + ], "application/json-patch+json") + @test Kuber._field(patched.spec.replicas) == 1 + @test Kuber.kuber_props(patched.metadata.labels)["patched"] == "yes" + + # a patch handed over as JSON text, which the 0.2.x client accepted + patched = update!(ctx, :Deployment, "hello-dep$testid", + """{"metadata": {"labels": {"via": "text"}}}""", + "application/merge-patch+json") + @test Kuber.kuber_props(patched.metadata.labels)["via"] == "text" + + # a strategic merge patch, k8s's own default and the third body shape + patched = update!(ctx, :Deployment, "hello-dep$testid", + Dict("metadata" => Dict("labels" => Dict("strategic" => "yes"))), + "application/strategic-merge-patch+json") + @test Kuber.kuber_props(patched.metadata.labels)["strategic"] == "yes" + + # …and a typed model as the patch body (JuliaRun patches Secrets this way) + secret = kuber_obj("""{"kind": "Secret", "apiVersion": "v1", + "metadata": {"name": "patch-secret$testid", "namespace": "default"}, + "data": {"a": "$(Base64.base64encode("one"))"}}""") + @test kuber_kind(put!(ctx, secret)) == "Secret" + updated = kuber_obj("""{"kind": "Secret", "apiVersion": "v1", + "metadata": {"name": "patch-secret$testid", "namespace": "default"}, + "data": {"a": "$(Base64.base64encode("two"))"}}""") + patchedsecret = update!(ctx, :Secret, "patch-secret$testid", updated, + "application/merge-patch+json") + # secret data is `format: byte`, which the runtime decodes for us: what + # comes back is the plaintext as bytes, NOT the base64 text the 0.2.x + # client handed over (G12a) + @test Kuber.kuber_props(patchedsecret.data)["a"] isa Vector{UInt8} + @test String(copy(Kuber.kuber_props(patchedsecret.data)["a"])) == "two" + @test kuber_kind(delete!(ctx, :Secret, "patch-secret$testid")) in ("Secret", "Status") + + # delete by object, reading kind and name off the model + res = delete!(ctx, patched) + @test kuber_kind(res) in ("Deployment", "Status") + + # `propagation_policy` matters here: without it the apiserver orphans + # the Job's pods, so every run of this suite leaves a Completed pod + # behind in `default`. CI never notices — a fresh kind cluster each + # time — but a local cluster accumulates them, and they are not inert: + # `list(ctx, :Pod)` is dominated by per-item response validation, so a + # namespace with 35 stale pods made that call 116 ms instead of 9 ms + # while re-measuring OpenAPIv1TrialResults.md §2. + res = delete!(ctx, :Job, "hello-job$testid"; propagation_policy = "Background") + @test kuber_kind(res) in ("Job", "Status") + end + @testset "Delete nginx service" begin res = delete!(ctx, :Service, "nginx-service$testid") - # delete! operations can return either the deleted object or a status object - # ref: https://github.com/kubernetes-client/csharp/issues/44 - @test isa(res, Kuber.kind_to_type(ctx, :Status)) || isa(res, Kuber.kind_to_type(ctx, :Service)) + # delete operations can return either the deleted object or a status + # object (https://github.com/kubernetes-client/csharp/issues/44). The two + # are types from different group modules, so compare the kind, not the + # type: this build has one Status type per group module. + @test kuber_kind(res) in ("Service", "Status") end @testset "Delete nginx pod" begin res = delete!(ctx, :Pod, "nginx-pod$testid") - # delete! operations can return either the deleted object or a status object - # ref: https://github.com/kubernetes-client/csharp/issues/44 - @test isa(res, Kuber.kind_to_type(ctx, :Pod)) || isa(res, Kuber.kind_to_type(ctx, :Status)) + @test kuber_kind(res) in ("Pod", "Status") end nothing end +function test_not_found(ctx) + @testset "Missing object raises KuberException" begin + err = try + get(ctx, :Pod, "no-such-pod-here") + nothing + catch e + e + end + @test err isa KuberException + @test err.code == 404 + @test kuber_kind(err.status) == "Status" + @test occursin("not found", err.message) + end +end + +""" + ensure_absent(ctx, kind, name; namespace=nothing) + +Delete an object if it is there, and wait until it is gone. + +The live testsets create and delete in the same block with no `finally`, so a +failure anywhere in the middle leaves objects behind — and the *next* run then +fails at `put!` with a 409 before reaching whatever actually broke, which hides +the real error behind a stale one. Against `kind` in CI this never shows up, +because the cluster is new every time; locally it turns one failure into two +confusing runs. +""" +function ensure_absent(ctx, kind::Symbol, name::String; namespace = nothing, timeout = 90.0) + nskwargs = namespace === nothing ? NamedTuple() : (; namespace = namespace) + isgone(e) = e isa Kuber.KuberException && e.code == 404 + try + # Background propagation for the same reason the Job delete below uses + # it: cleaning up a controller without taking its pods leaves debris + # that a later run then measures or trips over. + delete!(ctx, kind, name; propagation_policy = "Background", nskwargs...) + catch e + isgone(e) && return nothing + rethrow() + end + deadline = time() + timeout + while time() < deadline + try + get(ctx, kind, name; nskwargs...) + catch e + isgone(e) && return nothing + rethrow() + end + sleep(0.5) + end + error("$kind/$name is still present $(timeout)s after being deleted") +end + +""" + reset_test_objects(ctx, testid) + +Clear anything a previous interrupted run left behind, so a rerun reports the +failure it actually hits. +""" +function reset_test_objects(ctx, testid) + ensure_absent(ctx, :Pod, "nginx-pod$testid") + ensure_absent(ctx, :Service, "nginx-service$testid") + ensure_absent(ctx, :Job, "hello-job$testid") + ensure_absent(ctx, :Deployment, "hello-dep$testid") + ensure_absent(ctx, :Secret, "patch-secret$testid") + ensure_absent(ctx, :Namespace, "kuber-dict-test$testid") # cascades + # G6's kinds. The PersistentVolume is cluster-scoped, so a leftover one + # collides with the next run just as a namespaced object would; the claim + # goes first, since a bound PV waits on pv-protection. + ensure_absent(ctx, :ReplicaSet, "kuber-rs$testid") + ensure_absent(ctx, :DaemonSet, "kuber-ds$testid") + ensure_absent(ctx, :CronJob, "kuber-cj$testid") + ensure_absent(ctx, :RoleBinding, "kuber-rb$testid") + ensure_absent(ctx, :NetworkPolicy, "kuber-np$testid") + ensure_absent(ctx, :PersistentVolumeClaim, "kuber-pvc$testid") + ensure_absent(ctx, :PersistentVolume, "kuber-pv$testid") + ensure_absent(ctx, :ConfigMap, "kuber-shapes$testid") + ensure_absent(ctx, :Pod, "kuber-res$testid") + ensure_absent(ctx, :Secret, "kuber-secret$testid") +end + function test_versioned(ctx, testid) + reset_test_objects(ctx, testid) @testset "List Objects" begin list_cluster_components(ctx) list_namespace_objects(ctx) @@ -287,6 +486,10 @@ function test_versioned(ctx, testid) create_versioned_models(ctx) end + @testset "Not Found" begin + test_not_found(ctx) + end + # start a watch on pods lck = ReentrantLock() events = Any[] @@ -304,30 +507,1109 @@ function test_versioned(ctx, testid) create_delete_job(ctx, testid) end + @testset "Create/Delete from dicts" begin + create_delete_from_dicts(ctx, testid) + end + + @testset "More kinds" begin + create_delete_more_kinds(ctx, testid) + end + + @testset "Data shapes" begin + data_shapes(ctx, testid) + end + + @testset "Secret round trip" begin + secret_round_trip(ctx, testid) + end + + @testset "Cluster-scoped writes" begin + cluster_scoped_writes(ctx, testid) + end + + @testset "Selector-scoped watch across namespaces" begin + watch_selector_all_namespaces(ctx, testid) + end + + @testset "Long-lived watch, compressed (G5a)" begin + long_lived_watch(ctx, testid) + end + @testset "Watch Events" begin - timedwait(10.0; pollint=1.0) do + timedwait(30.0; pollint = 1.0) do lock(lck) do - any(isa(event, Typedefs.CoreV1.WatchEvent) && (event.type == "DELETED") for event in events) + any(isa(event, KuberEvent) && (event.type == "DELETED") for event in events) end end lock(lck) do @test !isempty(events) + # the event protocol is unchanged: the initial typed List result + # first, then events — except that events are Kuber's own KuberEvent + # instead of the generated WatchEvent, so `event.type` still reads + # naturally (the generated field is `type_`), and `event.object` is + # already the typed model. `kuber_obj(ctx, event.object)` is no + # longer needed, though it still accepts a dict for compatibility. + @test any(isa(event, KuberEvent) for event in events) + @test any(isa(event, Kuber.kind_to_type(ctx, :PodList)) for event in events) for event in events - @test isa(event, Union{Typedefs.CoreV1.WatchEvent,Typedefs.CoreV1.PodList}) - # Watch event objects parse to `JSON.Object` under JSON.jl 1.x — - # an AbstractDict, not a Dict{String,Any}. `kuber_obj` must accept - # them: a MethodError here used to kill the stream processor and - # leave the watch silently deaf (see the watch-processor-failure - # test below for the propagation side). - if isa(event, Typedefs.CoreV1.WatchEvent) - obj = Kuber.kuber_obj(ctx, event.object) - @test isa(obj, OpenAPI.APIModel) + @test isa(event, Union{KuberEvent,Kuber.kind_to_type(ctx, :PodList)}) + if isa(event, KuberEvent) + @test event.type in ("ADDED", "MODIFIED", "DELETED", "BOOKMARK") + @test kuber_kind(event.object) == "Pod" + @test isa(event.object, Kuber.kind_to_type(ctx, :Pod)) end end end end end +""" + create_delete_from_dicts(ctx, testid) + +`put!(ctx, O::Symbol, dict)` — the form most production writes go through, and +the one the rest of this suite never used (G13 in OpenAPIv1ConsumerGaps.md). + +Modelled on `services/JobLoops/src/hot_standby.jl`: a namespace from a +hand-built `Dict`, then a deployment from `JSON.parse` output — which is not a +`Dict` at all on JSON.jl 1.x, and is what a rendered template actually produces. +Between them the two cases cover both dictionary shapes a caller can arrive +with. +""" +function create_delete_from_dicts(ctx, testid) + ns = "kuber-dict-test$testid" + + # hot_standby.jl:521-525, verbatim in shape + namespace_yaml = Dict( + "apiVersion" => "v1", + "kind" => "Namespace", + "metadata" => Dict("name" => ns), + ) + created_ns = put!(ctx, :Namespace, namespace_yaml) + @test kuber_kind(created_ns) == "Namespace" + @test created_ns.metadata.name == ns + # the dict form resolves the same type the typed form would + @test isa(created_ns, Kuber.kind_to_type(ctx, :Namespace)) + + deployment_spec = JSON.parse("""{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": {"name": "dict-deploy$testid", "labels": {"app": "dict-deploy$testid"}}, + "spec": { + "replicas": 1, + "selector": {"matchLabels": {"app": "dict-deploy$testid"}}, + "template": { + "metadata": {"labels": {"app": "dict-deploy$testid"}}, + "spec": {"containers": [{ + "name": "nginx", + "image": "nginx", + "ports": [{"containerPort": 80}], + "resources": {"limits": {"memory": "128Mi", "cpu": "500m"}} + }]} + } + } + }""") + # …and on JSON.jl 1.x that is a JSON.Object, not a Dict at all. This is why + # `put!`'s dict method is typed `v::AbstractDict` and not master's + # `Dict{String,Any}`: with the narrower signature a parsed template would + # miss this method entirely and fall through to the untyped one. + @test deployment_spec isa AbstractDict + @test !(deployment_spec isa Dict) + + created = put!(ctx, :Deployment, deployment_spec; namespace = ns) + @test kuber_kind(created) == "Deployment" + @test created.metadata.name == "dict-deploy$testid" + @test created.metadata.namespace == ns + @test created.spec.replicas == 1 + # nested arrays and maps survived the round trip through the model + container = created.spec.template.spec.containers[1] + @test container.image == "nginx" + @test Kuber.kuber_props(container.resources.limits)["cpu"].value == "500m" + # the apiVersion came off the dict, not off discovery + @test isa(created, REGISTRY.KIND_TYPES[("apps/v1", "Deployment")]) + + # a dict with no "kind" is completed from the symbol (simpleapi.jl's merge) + kindless = Dict{String,Any}( + "apiVersion" => "v1", + "metadata" => Dict{String,Any}("name" => "dict-cm$testid"), + "data" => Dict{String,Any}("greeting" => "hello"), + ) + cm = put!(ctx, :ConfigMap, kindless; namespace = ns) + @test kuber_kind(cm) == "ConfigMap" + @test Kuber.kuber_props(cm.data)["greeting"] == "hello" + @test !haskey(kindless, "kind") # the caller's dict is left alone + + @test kuber_kind(delete!(ctx, :ConfigMap, "dict-cm$testid"; namespace = ns)) in ("ConfigMap", "Status") + @test kuber_kind(delete!(ctx, :Deployment, "dict-deploy$testid"; namespace = ns)) in ("Deployment", "Status") + @test kuber_kind(delete!(ctx, :Namespace, ns)) in ("Namespace", "Status") +end + +""" + data_shapes(ctx, testid) + +The shapes consumers actually read off a live result — G9, G10 and G11 in +OpenAPIv1ConsumerGaps.md. + +One ConfigMap carries all three: it has labels, annotations and data, no +controller writes to it, and creating it makes the ConfigMap list non-empty, +which a list-shape assertion needs to mean anything. +""" +function data_shapes(ctx, testid) + name = "kuber-shapes$testid" + configmap = kuber_obj("""{ + "kind": "ConfigMap", + "apiVersion": "v1", + "metadata": { + "name": "$name", + "namespace": "default", + "labels": {"name": "$name", "version": "7"}, + "annotations": {"kuber.test/note": "round trip", "kuber.test/seq": "1"} + }, + "data": {"greeting": "hello"} + }""") + + @testset "labels and annotations round trip (G9)" begin + created = put!(ctx, configmap) + @test kuber_kind(created) == "ConfigMap" + fetched = get(ctx, :ConfigMap, name) + + labels = Kuber.kuber_props(fetched.metadata.labels) + @test labels["name"] == name + # `labels["version"]` is exactly what JobLoops' networkpolicy.jl:114 + # does to decide whether a policy needs updating + @test labels["version"] == "7" + annotations = Kuber.kuber_props(fetched.metadata.annotations) + @test annotations["kuber.test/note"] == "round trip" + @test annotations["kuber.test/seq"] == "1" + @test Kuber.kuber_props(fetched.data)["greeting"] == "hello" + + # …and the reason kuber_props is needed at all: a k8s string map is an + # open struct, not a dictionary, so the 0.2.x `labels["version"]` is a + # MethodError rather than a wrong answer. This is the single assertion + # that would have caught the networkpolicy.jl read. + raw = Kuber._field(fetched.metadata.labels) + @test !(raw isa AbstractDict) + @test_throws MethodError raw["version"] + end + + @testset "list shape (G11)" begin + listed = list(ctx, :ConfigMap) + # the guard JuliaRun's provisioning.jl:111 puts around every list result + @test hasproperty(listed, :items) + items = listed.items + @test items isa Vector + @test !isempty(items) + @test any(i -> Kuber._field(i.metadata.name) == name, items) + + # A list item IS the standalone type, as it was on master. It briefly + # was not: k8s wraps the element `$ref` in an `allOf` so it can hang a + # description beside it, and read literally that is a new schema, so the + # generator minted a `…ListItemsItem` per list kind. Patch rule §7 + # collapses the wrapper. G18. + standalone = Kuber.kind_to_type(ctx, :ConfigMap) + @test eltype(items) === standalone + @test all(i -> i isa standalone, items) + # …but k8s does not populate `kind` on list items, so the object form of + # `delete!` still cannot take one. That half was never a regression — + # master read the same absent field — and rule §7 does not change it. + @test Kuber.kuber_kind(items[1]) == "" + err = try + delete!(ctx, items[1]) + nothing + catch e + e + end + @test err isa ArgumentError + + # _resource_version is unit-tested on synthetic dicts and objects; this + # is it against a real list, and against the field it reads + rv = Kuber._resource_version(listed) + @test rv isa String + @test !isempty(rv) + @test rv == Kuber._field(listed.metadata.resourceversion) + # per-item resource versions are what K8sReflector:12 keys its store on + @test all(i -> Kuber._resource_version(i) isa String, items) + end + + @testset "resource_version on a non-watch read (G10)" begin + rv = Kuber._resource_version(list(ctx, :ConfigMap)) + # the generated spelling is a real query parameter on list operations: + # "0" means "any version you have cached", which every server can serve + cached = list(ctx, :ConfigMap; resourceversion = "0") + @test kuber_kind(cached) == "ConfigMapList" + + rvnum = tryparse(Int, rv) + if rvnum === nothing + @warn "SKIPPING the resource_version comparison: $SERVER reports a non-numeric resourceVersion ($rv)" + else + # A version the cluster has never reached. Asking for it through the + # generated spelling reaches the server, which waits for it briefly + # and then gives up — proof the parameter is on the wire. + huge = string(rvnum + 1_000_000_000) + err = try + list(ctx, :ConfigMap; resourceversion = huge, max_tries = 1) + nothing + catch e + e + end + @test err isa KuberException + @test err.code in (410, 504) + + # The documented spelling now behaves identically — `list` forwards + # it to the operation on the non-watch path (G17). It used to be + # swallowed by the named parameter and consulted only when watching, + # so the same impossible version succeeded. + err = try + list(ctx, :ConfigMap; resource_version = huge, max_tries = 1) + nothing + catch e + e + end + @test err isa KuberException + @test err.code in (410, 504) + + # and the ordinary "not older than" read, which is what a consumer + # actually passes: a version the cluster has certainly reached + fresh = list(ctx, :ConfigMap; resource_version = rv, max_tries = 1) + @test kuber_kind(fresh) == "ConfigMapList" + @test Kuber._resource_version(fresh) !== nothing + # "0" is the cheap cached read + @test kuber_kind(list(ctx, :ConfigMap; resource_version = "0")) == "ConfigMapList" + + # The single-object read behaves the same way now. k8s does not + # declare resourceVersion on read operations even though the + # apiserver honours it, so patch rule §8 declares it — this + # assertion is what proves the rule reached the wire. + err = try + get(ctx, :ConfigMap, name; resource_version = huge, max_tries = 1) + nothing + catch e + e + end + @test err isa KuberException + @test err.code in (410, 504) + + # …and the reads a consumer actually makes + one = get(ctx, :ConfigMap, name; resource_version = "0", max_tries = 1) + @test kuber_kind(one) == "ConfigMap" + @test Kuber._field(one.metadata.name) == name + # K8sReflector.jl:136-141's shape: re-read not older than a version + # it already saw + seen = Kuber._resource_version(one) + again = get(ctx, :ConfigMap, name; resource_version = seen, max_tries = 1) + @test Kuber._resource_version(again) == seen + end + end + + @testset "resource limits and requests are open structs (G12)" begin + # `resources.limits["cpu"]` is what every consumer wrote against 0.2.x + # and what `clustermgmt.jl:281-285` still writes. Both maps are open + # structs now, so both need kuber_props — and `requests` matters more + # than `limits`, because `container_resource` prefers it. + # + # A nodeSelector no node carries keeps the pod Pending, which is all + # this needs: the spec comes back on the create response. + podname = "kuber-res$testid" + pod = kuber_obj("""{ + "kind": "Pod", + "apiVersion": "v1", + "metadata": {"name": "$podname", "namespace": "default"}, + "spec": { + "nodeSelector": {"kuber-test/no-such-node": "true"}, + "containers": [{ + "name": "busybox$testid", + "image": "busybox", + "args": ["sleep", "3600"], + "resources": { + "limits": {"cpu": "500m", "memory": "128Mi"}, + "requests": {"cpu": "250m", "memory": "64Mi"} + } + }] + } + }""") + created = put!(ctx, pod) + resources = Kuber._field(created.spec.containers[1].resources) + @test resources !== nothing + + limits = Kuber.kuber_props(resources.limits) + requests = Kuber.kuber_props(resources.requests) + @test limits["cpu"].value == "500m" + @test limits["memory"].value == "128Mi" + @test requests["cpu"].value == "250m" + @test requests["memory"].value == "64Mi" + # Quantity is still a struct with a single `value`, so JuliaRun's + # `string(cpu.value)` (api.jl:1841) survives structurally — only the + # type identity differs, which is C1's problem + @test fieldnames(typeof(limits["cpu"])) == (:value,) + @test limits["cpu"].value isa Union{Float64,String} + + # …and the reason kuber_props is needed: neither map is a dictionary, so + # the 0.2.x `in keys(res)` / `res["cpu"]` pair is a MethodError, not a + # wrong answer. This is the shape of the clustermgmt.jl:281-285 break. + raw = Kuber._field(resources.requests) + @test !(raw isa AbstractDict) + @test_throws MethodError keys(raw) + @test_throws MethodError raw["cpu"] + + # After patch rule §7 `resources` is the shared ResourceRequirements + # rather than a per-container positional copy, so its maps are one type + # across every kind that embeds a pod template. + @test typeof(resources) === REGISTRY.GROUP_MODULES["v1"].IoK8sApiCoreV1ResourceRequirements + + @test kuber_kind(delete!(ctx, :Pod, podname)) in ("Pod", "Status") + end + + @test kuber_kind(delete!(ctx, :ConfigMap, name)) in ("ConfigMap", "Status") + nothing +end + +""" + model_fieldtype(T, field) -> Type + +The model type behind a generated field, with `Absent` and `Nothing` stripped +off its union. Lets a test build a nested model without naming the generated +type — the names are an implementation detail of the pipeline, and +`kind_to_type` deliberately exists so tests do not spell them. +""" +function model_fieldtype(T::Type, field::Symbol) + ts = Base.uniontypes(fieldtype(T, field)) + return only(filter(t -> t !== Nothing && !(t <: Kuber.Runtime.Absent), ts)) +end + +""" + secret_round_trip(ctx, testid) + +`format: byte` out and back, and `stringData` — G7. + +`JuliaRun/src/kubernetes/api.jl:203-248` builds Secrets whose `data` values are +raw `Vector{UInt8}`: `_as_binary_secret` base64-*decodes* anything that looks +base64 before handing it over, so what reaches Kuber is always bytes. The 0.2.x +client base64-encoded them onto the wire because the field is `format: byte`, +and the 1.0 runtime does the same in both directions — so those call sites +survive the port on their values. What changed is the container: `data` is an +open struct now, not a `Dict`, so `Secret(; data=bindata)` has to become +`Secret(; data=SecretData(additional_properties=bindata))`. +""" +function secret_round_trip(ctx, testid) + name = "kuber-secret$testid" + SecretT = Kuber.kind_to_type(ctx, :Secret) + DataT = model_fieldtype(SecretT, :data) + StringDataT = model_fieldtype(SecretT, :stringdata) + MetaT = model_fieldtype(SecretT, :metadata) + + # deliberately not valid UTF-8, so a round trip that "works" by treating the + # value as text cannot pass this + binary = UInt8[0x00, 0xff, 0xfe, 0x01, 0x80] + token = Vector{UInt8}(codeunits("s3cr3t-$testid")) + + secret = SecretT(; + apiversion = "v1", + kind = "Secret", + type_ = "Opaque", + metadata = MetaT(; name = name, namespace = "default"), + data = DataT(; additional_properties = Dict("token" => token, "binary" => binary)), + stringdata = StringDataT(; additional_properties = Dict("plain" => "hello-$testid")), + ) + + created = put!(ctx, secret) + @test kuber_kind(created) == "Secret" + + fetched = get(ctx, :Secret, name) + data = Kuber.kuber_props(fetched.data) + # byte-identical both ways, including the bytes no encoding-by-accident + # would survive + @test data["token"] == token + @test data["binary"] == binary + @test data["token"] isa Vector{UInt8} + # …so this is how a consumer reads one now. `String(base64decode(v))` — the + # 0.2.x idiom — decodes a second time and yields rubbish rather than an + # error, which is the G12a trap. + @test String(copy(data["token"])) == "s3cr3t-$testid" + + # stringData is write-only: the apiserver folds it into data and never + # returns it, so a consumer that writes it must not expect to read it back + @test data["plain"] == Vector{UInt8}(codeunits("hello-$testid")) + @test Kuber._field(fetched.stringdata, nothing) === nothing + + # JuliaRun's update_secret shape: a whole typed Secret as a merge patch, + # carrying raw bytes again + rotated = Vector{UInt8}(codeunits("rotated-$testid")) + patch = SecretT(; + apiversion = "v1", + kind = "Secret", + metadata = MetaT(; name = name), + data = DataT(; additional_properties = Dict("token" => rotated)), + ) + patched = update!(ctx, :Secret, name, patch, "application/merge-patch+json") + patcheddata = Kuber.kuber_props(patched.data) + @test patcheddata["token"] == rotated + # A merge patch (RFC 7386) merges the map key by key rather than replacing + # it, so keys the patch does not mention survive — only an explicit null + # removes one. Pinned because the opposite is the natural guess, and it is + # the difference between rotating one key and dropping every other secret in + # the object. + @test patcheddata["binary"] == binary + @test sort!(collect(keys(patcheddata))) == ["binary", "plain", "token"] + + @test kuber_kind(delete!(ctx, :Secret, name)) in ("Secret", "Status") + nothing +end + +""" + cluster_scoped_writes(ctx, testid) + +Writing to a cluster-scoped kind — G8. + +The Namespace half is already covered by `create_delete_from_dicts` (G13) and +the PersistentVolume half by `create_delete_more_kinds` (G6), both +create/delete. What was left is Node, and Node is different in kind: **no +consumer creates one.** The monorepo's `set_node_label`, `set_node_cordon` and +`taint_update_patch` all *patch* an existing node. Creating a Node object +through the API is possible, but it would test an operation nobody performs and +leave a kubelet-less NotReady node on the cluster for metrics-server and the +scheduler to trip over, so this patches a real node and puts it back. + +The patches are the two consumer shapes: a merge patch carrying a label +(`set_node_label`) and a json-patch whose value is a nested array of dicts +(`taint_update_patch`). The taint uses `PreferNoSchedule` rather than +`NoSchedule`, and nothing here cordons: the rest of the live suite schedules +pods on the same node. +""" +function cluster_scoped_writes(ctx, testid) + nodes = list(ctx, :Node) + @test kuber_kind(nodes) == "NodeList" + @test !isempty(nodes.items) + nodename = Kuber._field(nodes.items[1].metadata.name) + + # cluster-scoped resolution: ctx.namespace is "default", and the read still + # goes to /api/v1/nodes/ because the :namespaced lookup falls through + node = get(ctx, :Node, nodename) + @test kuber_kind(node) == "Node" + @test isa(node, Kuber.kind_to_type(ctx, :Node)) + + labelkey = "kuber-test.juliahub.com/g8" + # set_node_label's shape: a merge patch on metadata.labels + labelled = update!(ctx, :Node, nodename, + Dict("metadata" => Dict("labels" => Dict(labelkey => testid))), + "application/merge-patch+json") + @test Kuber.kuber_props(labelled.metadata.labels)[labelkey] == testid + + # …and removing it again: in a merge patch an explicit null deletes the key, + # which is the only way to remove one (G7 covers the other half of RFC 7386, + # that unmentioned keys survive) + unlabelled = update!(ctx, :Node, nodename, + Dict("metadata" => Dict("labels" => Dict(labelkey => nothing))), + "application/merge-patch+json") + @test !haskey(Kuber.kuber_props(unlabelled.metadata.labels), labelkey) + + # taint_update_patch's shape: a json-patch whose value is an array of dicts. + # Append rather than replace so the node's existing taints are untouched — + # a control-plane node has one, and dropping it would be a live change to + # the cluster rather than a test. + original = Kuber._field(Kuber._field(node.spec).taints, nothing) + taint = Dict{String,Any}("key" => "kuber-test.juliahub.com/g8", + "value" => testid, + "effect" => "PreferNoSchedule") + addop, removeop = if original === nothing + (Dict{String,Any}("op" => "add", "path" => "/spec/taints", "value" => [taint]), + Dict{String,Any}("op" => "remove", "path" => "/spec/taints")) + else + (Dict{String,Any}("op" => "add", "path" => "/spec/taints/-", "value" => taint), + Dict{String,Any}("op" => "remove", "path" => "/spec/taints/$(length(original))")) + end + + tainted = update!(ctx, :Node, nodename, [addop], "application/json-patch+json") + taints = Kuber._field(tainted.spec.taints, []) + @test any(t -> Kuber._field(t.key) == "kuber-test.juliahub.com/g8", taints) + @test length(taints) == (original === nothing ? 1 : length(original) + 1) + + restored = update!(ctx, :Node, nodename, [removeop], "application/json-patch+json") + remaining = Kuber._field(restored.spec.taints, []) + @test !any(t -> Kuber._field(t.key) == "kuber-test.juliahub.com/g8", remaining) + @test length(remaining) == (original === nothing ? 0 : length(original)) + + nothing +end + +status_of(obj) = Kuber._field(obj.status, nothing) + +""" + get_when(cond, ctx, kind, name; namespace=nothing) -> model + +`get` in a poll loop until `cond(object)` holds. + +Several of the kinds in `create_delete_more_kinds` are only interesting once +their controller has written a status: a `get` issued immediately after `put!` +decodes an empty status block and so checks almost none of the kind's schema, +which is the whole point of G6. +""" +function get_when(cond, ctx, kind::Symbol, name::String; namespace = nothing, timeout = 60.0) + nskwargs = namespace === nothing ? NamedTuple() : (; namespace = namespace) + obj = nothing + ok = timedwait(timeout; pollint = 0.5) do + obj = get(ctx, kind, name; nskwargs...) + cond(obj) + end + ok === :ok || error("$kind/$name did not reach the expected state in $(timeout)s") + return obj +end + +""" + create_delete_more_kinds(ctx, testid) + +The kinds consumers write that the rest of the live suite never submits — G6 in +OpenAPIv1ConsumerGaps.md. + +Strict response validation checks every kind's schemas independently, and two of +the six patch rules were found by submitting a kind for the first time, so an +untested kind is an unchecked set of schemas rather than merely an untested code +path. Each kind here is therefore taken through all four decode paths that have +distinct schemas: create, a `get` once the controller has filled in a status, +a `list` (a separate `…List` schema — and an empty one would check nothing), and +delete (object-or-`Status`). + +The objects are shaped after the real consumer templates, not invented: +ReplicaSet and DaemonSet from `JuliaRun/src/kubernetes/templates/`, CronJob from +`templates/julia/cronjob/cronjob.jl`, RoleBinding from +`src/kubernetes/provisioning.jl:110-136`, NetworkPolicy after JobLoops'. + +Nothing here schedules a workload — `replicas: 0`, a `nodeSelector` no node +carries, `suspend: true` — which keeps the run cheap and, incidentally, keeps +the concurrent `:Pod` watch's event assertions clean. + +Two of the fixtures are deliberately declawed relative to the templates they +copy. The RoleBinding names a Role that does not exist instead of JuliaRun's +`ClusterRole/admin`: RBAC permits a dangling `roleRef`, so the schema is +identical and the privilege grant is not. The NetworkPolicy selects on a label +no pod carries rather than the empty selector, which would be deny-all-ingress +for the namespace — inert under kind's CNI, but not under an enforcing one. +""" +function create_delete_more_kinds(ctx, testid) + replicaset = kuber_obj("""{ + "kind": "ReplicaSet", + "apiVersion": "apps/v1", + "metadata": {"name": "kuber-rs$testid", "labels": {"name": "kuber-rs$testid"}}, + "spec": { + "replicas": 0, + "selector": {"matchLabels": {"name": "kuber-rs$testid"}}, + "template": { + "metadata": {"labels": {"name": "kuber-rs$testid"}}, + "spec": {"containers": [{ + "name": "busybox$testid", + "image": "busybox", + "args": ["sleep", "3600"] + }]} + } + } + }""") + + daemonset = kuber_obj("""{ + "kind": "DaemonSet", + "apiVersion": "apps/v1", + "metadata": {"name": "kuber-ds$testid", "labels": {"name": "kuber-ds$testid"}}, + "spec": { + "selector": {"matchLabels": {"name": "kuber-ds$testid"}}, + "template": { + "metadata": {"labels": {"name": "kuber-ds$testid"}}, + "spec": { + "nodeSelector": {"kuber-test/no-such-node": "true"}, + "containers": [{ + "name": "busybox$testid", + "image": "busybox", + "args": ["sleep", "3600"] + }] + } + } + } + }""") + + cronjob = kuber_obj("""{ + "kind": "CronJob", + "apiVersion": "batch/v1", + "metadata": {"name": "kuber-cj$testid", "labels": {"name": "kuber-cj$testid"}}, + "spec": { + "schedule": "0 0 31 2 *", + "concurrencyPolicy": "Forbid", + "suspend": true, + "startingDeadlineSeconds": 60, + "jobTemplate": { + "spec": { + "template": { + "metadata": {"labels": {"name": "kuber-cj$testid"}}, + "spec": { + "restartPolicy": "Never", + "containers": [{ + "name": "busybox$testid", + "image": "busybox", + "args": ["/bin/sh", "-c", "date"] + }] + } + } + } + } + } + }""") + + rolebinding = kuber_obj("""{ + "kind": "RoleBinding", + "apiVersion": "rbac.authorization.k8s.io/v1", + "metadata": { + "name": "kuber-rb$testid", + "namespace": "default", + "labels": {"name": "kuber-rb$testid"} + }, + "roleRef": { + "apiGroup": "rbac.authorization.k8s.io", + "kind": "Role", + "name": "kuber-test-role$testid" + }, + "subjects": [{"kind": "ServiceAccount", "name": "default", "namespace": "default"}] + }""") + + networkpolicy = kuber_obj("""{ + "kind": "NetworkPolicy", + "apiVersion": "networking.k8s.io/v1", + "metadata": { + "name": "kuber-np$testid", + "namespace": "default", + "labels": {"name": "kuber-np$testid", "version": "1"} + }, + "spec": { + "podSelector": {"matchLabels": {"kuber-test-np": "$testid"}}, + "policyTypes": ["Ingress"], + "ingress": [{ + "from": [{"podSelector": {"matchLabels": {"kuber-test-np": "$testid"}}}], + "ports": [{"protocol": "TCP", "port": 80}] + }] + } + }""") + + # A PV and a PVC that can never bind to each other: they name different + # storage classes. A bound PV would sit in Terminating behind pv-protection + # until the claim was gone, which makes cleanup order matter; this way it + # does not. Retain for the same reason. + persistentvolume = kuber_obj("""{ + "kind": "PersistentVolume", + "apiVersion": "v1", + "metadata": {"name": "kuber-pv$testid", "labels": {"name": "kuber-pv$testid"}}, + "spec": { + "capacity": {"storage": "16Mi"}, + "accessModes": ["ReadWriteOnce"], + "persistentVolumeReclaimPolicy": "Retain", + "storageClassName": "kuber-test-pv$testid", + "hostPath": {"path": "/tmp/kuber-test-pv$testid"} + } + }""") + + persistentvolumeclaim = kuber_obj("""{ + "kind": "PersistentVolumeClaim", + "apiVersion": "v1", + "metadata": {"name": "kuber-pvc$testid", "namespace": "default"}, + "spec": { + "accessModes": ["ReadWriteOnce"], + "storageClassName": "kuber-test-pvc$testid", + "resources": {"requests": {"storage": "16Mi"}} + } + }""") + + @testset "ReplicaSet" begin + created = put!(ctx, replicaset) + @test kuber_kind(created) == "ReplicaSet" + @test Kuber._field(created.spec.replicas) == 0 + # status is written by the controller, so it is empty on the create + # response and only complete on a later read. Generated field names are + # the lowercased JSON names — `observedgeneration`, not + # `observedGeneration` and not `observed_generation`. + fetched = get_when(ctx, :ReplicaSet, "kuber-rs$testid") do rs + s = status_of(rs) + s !== nothing && Kuber._field(s.observedgeneration, 0) > 0 + end + @test Kuber._field(fetched.status.replicas) == 0 + listed = list(ctx, :ReplicaSet) + @test kuber_kind(listed) == "ReplicaSetList" + @test any(i -> Kuber._field(i.metadata.name) == "kuber-rs$testid", listed.items) + @test kuber_kind(delete!(ctx, :ReplicaSet, "kuber-rs$testid")) in ("ReplicaSet", "Status") + end + + @testset "DaemonSet" begin + created = put!(ctx, daemonset) + @test kuber_kind(created) == "DaemonSet" + # no node carries the selector, so the controller settles on wanting none + fetched = get_when(ctx, :DaemonSet, "kuber-ds$testid") do ds + s = status_of(ds) + s !== nothing && Kuber._field(s.observedgeneration, 0) > 0 + end + # Read this as a decode assertion rather than a claim about the + # controller: desirednumberscheduled is a required field of + # DaemonSetStatus, and 0 is both its initial value and the right answer + # for a selector no node matches, so a read that landed before the + # controller evaluated anything would pass just as well. + @test Kuber._field(fetched.status.desirednumberscheduled) == 0 + # `get` with a label selector and no name is how JuliaRun reads + # DaemonSets (api.jl:993) and RoleBindings (provisioning.jl:110): it + # resolves to the list operation and answers with a List, which the + # caller then guards with `hasproperty(x, :items)`. + selected = get(ctx, :DaemonSet; label_selector = sel("name", :in, "kuber-ds$testid")) + @test kuber_kind(selected) == "DaemonSetList" + @test length(selected.items) == 1 + @test Kuber._field(selected.items[1].metadata.name) == "kuber-ds$testid" + @test kuber_kind(delete!(ctx, :DaemonSet, "kuber-ds$testid")) in ("DaemonSet", "Status") + end + + @testset "CronJob" begin + created = put!(ctx, cronjob) + @test kuber_kind(created) == "CronJob" + @test Kuber._field(created.spec.schedule) == "0 0 31 2 *" + @test Kuber._field(created.spec.suspend) === true + fetched = get(ctx, :CronJob, "kuber-cj$testid") + @test Kuber._field(fetched.spec.concurrencypolicy) == "Forbid" + @test Kuber._field(fetched.spec.startingdeadlineseconds) == 60 + listed = list(ctx, :CronJob) + @test kuber_kind(listed) == "CronJobList" + @test any(i -> Kuber._field(i.metadata.name) == "kuber-cj$testid", listed.items) + @test kuber_kind(delete!(ctx, :CronJob, "kuber-cj$testid")) in ("CronJob", "Status") + end + + @testset "RoleBinding" begin + created = put!(ctx, rolebinding) + @test kuber_kind(created) == "RoleBinding" + # rbac.authorization.k8s.io is its own group module, and nothing else in + # the live suite submits to it: this pins that discovery resolved it + @test isa(created, REGISTRY.KIND_TYPES[("rbac.authorization.k8s.io/v1", "RoleBinding")]) + @test Kuber._field(created.roleref.name) == "kuber-test-role$testid" + @test Kuber._field(created.subjects[1].kind) == "ServiceAccount" + selected = get(ctx, :RoleBinding; label_selector = sel("name", :in, "kuber-rb$testid")) + @test kuber_kind(selected) == "RoleBindingList" + @test length(selected.items) == 1 + @test kuber_kind(delete!(ctx, :RoleBinding, "kuber-rb$testid")) in ("RoleBinding", "Status") + end + + @testset "NetworkPolicy" begin + created = put!(ctx, networkpolicy) + @test kuber_kind(created) == "NetworkPolicy" + @test isa(created, REGISTRY.KIND_TYPES[("networking.k8s.io/v1", "NetworkPolicy")]) + # the `version` label JobLoops compares to decide whether to update + # (networkpolicy.jl:114) is an open struct now, so it needs kuber_props + @test Kuber.kuber_props(created.metadata.labels)["version"] == "1" + fetched = get(ctx, :NetworkPolicy, "kuber-np$testid") + @test Kuber._field(fetched.spec.policytypes) == ["Ingress"] + @test Kuber.kuber_props(fetched.spec.podselector.matchlabels)["kuber-test-np"] == testid + listed = list(ctx, :NetworkPolicy) + @test kuber_kind(listed) == "NetworkPolicyList" + @test kuber_kind(delete!(ctx, :NetworkPolicy, "kuber-np$testid")) in ("NetworkPolicy", "Status") + end + + @testset "PersistentVolume and PersistentVolumeClaim" begin + created = put!(ctx, persistentvolume) + @test kuber_kind(created) == "PersistentVolume" + # cluster-scoped, so this also covers the OPS :cluster fallback for a + # kind that is not Namespace + @test Kuber.kuber_props(created.spec.capacity)["storage"].value == "16Mi" + pv = get_when(ctx, :PersistentVolume, "kuber-pv$testid") do v + s = status_of(v) + s !== nothing && Kuber._field(s.phase, "") == "Available" + end + @test Kuber._field(pv.spec.persistentvolumereclaimpolicy) == "Retain" + + claim = put!(ctx, persistentvolumeclaim) + @test kuber_kind(claim) == "PersistentVolumeClaim" + # it names a storage class nothing provides, so it stays Pending — which + # is all this needs: the point is the schema, not the binding + pvc = get_when(ctx, :PersistentVolumeClaim, "kuber-pvc$testid") do c + s = status_of(c) + s !== nothing && Kuber._field(s.phase, "") == "Pending" + end + @test Kuber.kuber_props(pvc.spec.resources.requests)["storage"].value == "16Mi" + + listed = list(ctx, :PersistentVolumeClaim) + @test kuber_kind(listed) == "PersistentVolumeClaimList" + @test kuber_kind(delete!(ctx, :PersistentVolumeClaim, "kuber-pvc$testid")) in + ("PersistentVolumeClaim", "Status") + @test kuber_kind(delete!(ctx, :PersistentVolume, "kuber-pv$testid")) in + ("PersistentVolume", "Status") + end + + nothing +end + +""" + labelled_pod(name, namespace, labels) -> model + +A pod that exists to be selected, not to run. +""" +labelled_pod(name, namespace, labels) = kuber_obj("""{ + "kind": "Pod", + "apiVersion": "v1", + "metadata": {"name": "$name", "namespace": "$namespace", "labels": $(JSON.json(labels))}, + "spec": {"containers": [{"name": "busybox", "image": "busybox", "args": ["sleep", "3600"]}]} +}""") + +""" + watch_selector_all_namespaces(ctx, testid) + +The shape `K8sReflector` actually watches with (G4): kind `:Pod`, +`namespace=nothing` — so scope resolution has to fall through `:cluster` to +`:allns` — and a `label_selector` built by Kuber's own `sel` helper, exactly as +`JobLoops/src/k8s_job_pod_monitoring.jl:66` builds it. + +Both halves of the reflector's loop are covered: the initial `get` that fills its +store, and the watch that maintains it. The watch resumes from the list's +`resourceVersion`, which is what the reflector does and what removes the race +between establishing the watch and creating the object it should hear about. +""" +function watch_selector_all_namespaces(ctx, testid) + ns = "kuber-g4$testid" + marker = "g4-$testid" + selector = sel("kuber-test", :in, marker) + @test selector == "kuber-test in ($marker)" + + names = ["g4-here$testid", "g4-there$testid", "g4-other$testid", "g4-late$testid"] + ensure_absent(ctx, :Pod, names[1]; namespace = "default") + ensure_absent(ctx, :Namespace, ns) # takes the rest with it + put!(ctx, kuber_obj("""{"kind": "Namespace", "apiVersion": "v1", + "metadata": {"name": "$ns"}}""")) + + # One selected pod in each of two namespaces: a result carrying both is what + # makes this an all-namespaces read rather than a lucky single-namespace one. + # `namespace=` is not optional here — `put!` addresses the request with the + # context's namespace and does not read `metadata.namespace` off the object, + # so leaving it out is a 400 from the apiserver. `master` behaves the same + # way, and does not even offer the keyword. + put!(ctx, labelled_pod(names[1], "default", Dict("kuber-test" => marker)); namespace = "default") + put!(ctx, labelled_pod(names[2], ns, Dict("kuber-test" => marker)); namespace = ns) + + res = get(ctx, :Pod; label_selector = selector, namespace = nothing) + @test kuber_kind(res) == "PodList" + found = Dict(Kuber._field(p.metadata.name) => Kuber._field(p.metadata.namespace) for p in res.items) + @test Set(keys(found)) == Set(names[1:2]) + @test Set(values(found)) == Set(["default", ns]) + # the selector came back on the objects themselves + @test all(Kuber.kuber_props(p.metadata.labels)["kuber-test"] == marker for p in res.items) + + rv = Kuber._resource_version(res) + @test rv !== nothing + + events = Any[] + lck = ReentrantLock() + stream = Kuber.KuberEventStream(64) + watcher = @async watch(ctx, :Pod, stream; + label_selector = selector, namespace = nothing, resource_version = rv) + collector = @async for e in stream + lock(lck) do + push!(events, e) + end + end + + # created after the watch's resourceVersion, so both are events it must + # decide about: the unselected one first, so seeing the selected one proves + # the other was not merely late + put!(ctx, labelled_pod(names[3], ns, Dict("kuber-test" => "someone-else")); namespace = ns) + put!(ctx, labelled_pod(names[4], ns, Dict("kuber-test" => marker)); namespace = ns) + + sawlate() = lock(lck) do + any(e -> e isa KuberEvent && Kuber._field(e.object.metadata.name) == names[4], events) + end + @test timedwait(sawlate, 60.0; pollint = 0.5) == :ok + + close(stream) + @test timedwait(() -> istaskdone(watcher) && istaskdone(collector), 20.0) == :ok + + lock(lck) do + @test !isempty(events) + @test all(e -> e isa KuberEvent, events) # no list frame: we resumed from rv + seen = Set(Kuber._field(e.object.metadata.name) for e in events) + @test names[4] in seen + @test names[3] ∉ seen # the selector held on the stream + @test all(Kuber.kuber_props(e.object.metadata.labels)["kuber-test"] == marker for e in events) + end + + ensure_absent(ctx, :Pod, names[1]; namespace = "default") + ensure_absent(ctx, :Namespace, ns) # takes the pods inside it +end + +""" + long_lived_watch(ctx, testid) + +G5a: the compressible half of the long-lived watch, against a real apiserver. + +A watch is ended by the apiserver on its own timer — `--min-request-timeout`, +1800 s by default and randomized into `[1800, 3600)` — which is what made this +look like an hour-long test. It is not. `timeoutseconds` on the request produces +exactly the same clean close on demand, so several server-initiated closes cost +about ten seconds, and what they exercise is the same code path. + +Three things only a real apiserver can show. `test/watch_recovery.jl` covers all +of them against a fake one, which is the point: this checks that a real server +ends a watch the way the fake does. + +- **A watch the server ends is re-established, losing nothing.** Pods created + either side of a close each arrive exactly once — no drop across the gap, and + no replay of what was already delivered before it. +- **`BOOKMARK` events arrive when asked for, and disturb nothing.** Nothing else + exercises them anywhere: Kuber never sets `allowwatchbookmarks`, so they reach + a consumer only on request. A bookmark is a shape strict decoding has never + otherwise seen — the watched kind, carrying a `resourceVersion` and nothing + else, with `spec.containers` an explicit `null`. +- **An expired `resourceVersion` resyncs from a fresh list.** The apiserver + answers one with an in-stream `ERROR`/410 rather than an HTTP status, and + `resourceVersion=1` provokes it immediately — no waiting for etcd to compact. +""" +function long_lived_watch(ctx, testid) + ns = "kuber-g5a$testid" + ensure_absent(ctx, :Namespace, ns) + put!(ctx, kuber_obj("""{"kind": "Namespace", "apiVersion": "v1", + "metadata": {"name": "$ns"}}""")) + + # ── a server-ended watch loses nothing, and bookmarks ride along ──────── + events = Any[] + lck = ReentrantLock() + stream = Kuber.KuberEventStream(64) + # Start from a `resourceVersion` of our own rather than letting the watch + # find one. The events-only form lists internally to learn where to resume + # and then discards that list, so anything created between this call and + # that internal list is in the list, is thrown away with it, and is never + # announced. Locally the first pod below wins that race; on a slower cluster + # it loses, which is how CI found this. Seeding the version closes the + # window — the same thing `watch_selector_all_namespaces` does, and what a + # consumer wanting no gap between state and events has to do. + seed = get(ctx, :Pod; namespace = ns) + rv = Kuber._resource_version(seed) + @test rv !== nothing + watcher = @async watch(ctx, :Pod, stream; namespace = ns, resource_version = rv, + timeout_seconds = 3, allow_watch_bookmarks = true) + collector = @async for e in stream + lock(lck) do + push!(events, e) + end + end + + names = ["g5a-first$testid", "g5a-second$testid", "g5a-third$testid"] + started = time() + for (i, name) in enumerate(names) + i == 1 || sleep(3.5) # longer than timeout_seconds: cross a close + put!(ctx, labelled_pod(name, ns, Dict("kuber-test" => "g5a")); namespace = ns) + end + # The last two pods were created after the first generation had been closed + # by the server, so hearing about them at all means the pump re-established. + @test time() - started > 2 * 3.0 + + isadd(e, name) = e isa KuberEvent && e.type == "ADDED" && + Kuber._field(e.object.metadata.name) == name + sawall() = lock(lck) do + all(name -> any(e -> isadd(e, name), events), names) + end + @test timedwait(sawall, 60.0; pollint = 0.5) == :ok + + lock(lck) do + @test all(e -> e isa KuberEvent, events) # events-only form: no list frames + for name in names + # exactly once: nothing dropped across a close, nothing replayed after + @test count(e -> isadd(e, name), events) == 1 + end + + marks = filter(e -> e isa KuberEvent && e.type == "BOOKMARK", events) + @test !isempty(marks) + for m in marks + @test kuber_kind(m.object) == "Pod" + @test isa(m.object, Kuber.kind_to_type(ctx, :Pod)) + @test Kuber._resource_version(m.object) isa String + @test Kuber._field(m.object.metadata.name) === nothing + # `spec.containers` is required and comes back an explicit null, so + # a bookmark only decodes at all because patch rule §2 makes array + # properties nullable — the Go-nil-slice rule, on a live payload + @test Kuber._field(m.object.spec.containers) === nothing + end + end + + close(stream) + @test timedwait(() -> istaskdone(watcher) && istaskdone(collector), 20.0) == :ok + + # ── an expired resourceVersion resyncs from a fresh list ──────────────── + frames = Any[] + flck = ReentrantLock() + fstream = Kuber.KuberEventStream(64) + # Resuming from a given resourceVersion skips the initial list, so a list + # frame on this stream can only be the resync — there is no other source. + resyncer = @async list(Kuber.KuberWatchContext(ctx, fstream), :Pod; + watch = true, namespace = ns, resource_version = "1", + timeout_seconds = 3) + fcollector = @async for e in fstream + lock(flck) do + push!(frames, e) + end + end + + podlist = Kuber.kind_to_type(ctx, :PodList) + sawlist() = lock(flck) do + any(f -> isa(f, podlist), frames) + end + @test timedwait(sawlist, 60.0; pollint = 0.5) == :ok + lock(flck) do + resync = first(filter(f -> isa(f, podlist), frames)) + @test kuber_kind(resync) == "PodList" + # the resync frame is complete current state, which here is the three + # pods above — that is the contract a consumer rebuilds its cache on + got = Set(Kuber._field(p.metadata.name) for p in resync.items) + @test Set(names) ⊆ got + @test Kuber._resource_version(resync) isa String + end + + close(fstream) + @test timedwait(() -> istaskdone(resyncer) && istaskdone(fcollector), 20.0) == :ok + + ensure_absent(ctx, :Namespace, ns) # takes the pods inside it +end + +""" + test_metrics(ctx) + +`metrics.k8s.io` is served by metrics-server, not the apiserver, so it is only +present on clusters that run it — k3s does by default, `kind` does not. Skipped +with a warning rather than failed when the group is absent: its presence says +nothing about whether the client is correct. + +Everything here is a read, and each one is also a strict-validation check of a +document captured from a cluster rather than fetched from a release tag. +""" +function test_metrics(ctx) + if !haskey(ctx.apis, :Metrics) + @warn "SKIPPING the metrics tests: $SERVER does not serve metrics.k8s.io (no metrics-server)" + return + end + @test ctx.apis[:Metrics][1] === REGISTRY.GROUP_MODULES["metrics.k8s.io/v1beta1"] + @test ctx.modelapi[:NodeMetrics] === REGISTRY.GROUP_MODULES["metrics.k8s.io/v1beta1"] + + # NodeMetrics is cluster-scoped, so the default namespace has to fall back — + # `get(ctx, :NodeMetrics)` is the idiom Metrics.md documents. + nodes = get(ctx, :NodeMetrics) + @test kuber_kind(nodes) == "NodeMetricsList" + @test !isempty(nodes.items) + node = nodes.items[1] + name = Kuber._field(node.metadata.name) + @test !isempty(name) + # usage is a k8s string map of Quantity, so it is an open struct of wrappers + usage = Kuber.kuber_props(node.usage) + @test haskey(usage, "cpu") && haskey(usage, "memory") + @test usage["cpu"].value isa String + @test Kuber._field(node.window) !== nothing + + one = get(ctx, :NodeMetrics, name) + @test kuber_kind(one) == "NodeMetrics" + @test Kuber._field(one.metadata.name) == name + + # PodMetrics is namespaced, and also answers for all namespaces + pods = list(ctx, :PodMetrics; namespace = "kube-system") + @test kuber_kind(pods) == "PodMetricsList" + if !isempty(pods.items) + pod = pods.items[1] + containers = Kuber._field(pod.containers, []) + @test !isempty(containers) + @test Kuber.kuber_props(containers[1].usage)["cpu"].value isa String + podname = Kuber._field(pod.metadata.name) + @test kuber_kind(get(ctx, :PodMetrics, podname; namespace = "kube-system")) == "PodMetrics" + end + @test kuber_kind(list(ctx, :PodMetrics; namespace = "*")) == "PodMetricsList" +end + function test_all() ctx = init_context() @testset "Kuber Tests" begin @@ -335,67 +1617,45 @@ function test_all() test_versioned(ctx, "1") end - @testset "Set Timeouts" begin - test_set_timeout(ctx) + @testset "Request Options" begin + test_request_options(ctx) end @testset "Overridden API Versions" begin - @test ctx.apis[:Apiregistration][1].api == Kubernetes.ApiregistrationV1Api - @test ctx.apis[:Apps][1].api == Kubernetes.AppsV1Api + # apps and apiregistration.k8s.io each serve a single version now, so + # the old apps=>v1beta2 / apiregistration=>v1beta1 overrides are not + # expressible against a 1.35 server. autoscaling is: the server + # prefers v2, and v1 is still served. + @test ctx.apis[:Apiregistration][1] === REGISTRY.GROUP_MODULES["apiregistration.k8s.io/v1"] + @test ctx.apis[:Apps][1] === REGISTRY.GROUP_MODULES["apps/v1"] + @test ctx.apis[:Autoscaling][1] === REGISTRY.GROUP_MODULES["autoscaling/v2"] - ctx2 = init_context(("apiregistration.k8s.io"=>"v1beta1", "apps"=>"v1beta2"), false) - @test ctx2.apis[:Apiregistration][1].api == Kubernetes.ApiregistrationV1beta1Api - @test ctx2.apis[:Apps][1].api == Kubernetes.AppsV1beta2Api + ctx2 = init_context(("autoscaling" => "v1",), false) + @test ctx2.apis[:Autoscaling][1] === REGISTRY.GROUP_MODULES["autoscaling/v1"] + @test ctx2.modelapi[:HorizontalPodAutoscaler] === REGISTRY.GROUP_MODULES["autoscaling/v1"] + @test Kuber.kind_to_type(ctx2, :HorizontalPodAutoscaler) === + REGISTRY.KIND_TYPES[("autoscaling/v1", "HorizontalPodAutoscaler")] test_versioned(ctx2, "2") end + @testset "Metrics" begin + test_metrics(ctx) + end + @testset "Misc" begin iob = IOBuffer() show(iob, ctx) str = String(take!(iob)) - @test str == "Kubernetes namespace default at http://localhost:8001" - end - end -end - -function test_watch_processor_failure() - # A `streamprocessor` that throws must abort the watch promptly and - # propagate the error. Before the fix, the processor task died silently - # while `@sync` kept waiting on the (long-running) `watched` task — a - # deaf watch: events kept buffering with no error surfaced until the - # server dropped the connection. - ctx = KuberContext() # only passed through to KuberWatchContext; no server needed - producer = (watchctx) -> begin - # mimic the HTTP watch task: keep streaming events; ends only when the - # stream is closed under it (put! on a closed channel throws) - i = 0 - while true - put!(watchctx.stream, (i += 1)) - sleep(0.05) + @test str == "Kubernetes namespace default at $SERVER" end end - t0 = time() - @test_throws Exception watch(ctx, producer) do stream - take!(stream) - error("processor failure") - end - # must fail fast — processor death closes the stream, which kills the - # producer's next put! — not linger until the producer would have ended - @test (time() - t0) < 10.0 end -@testset "Watch processor failure aborts watch" begin - test_watch_processor_failure() +if server_reachable(SERVER) + test_all() +else + @warn """SKIPPING the live integration tests: no Kubernetes API server at $SERVER. + Start one with `kubectl proxy --port=8001`, or point KUBER_TEST_SERVER elsewhere. + The offline suites above still ran.""" end - -test_all() - -# Shutdown the kubectl proxy if we are running on github CI. -# This is to close network connections that libcurl would otherwise keep open and -# that leads to segfault in some versions of julia when the process exits. This is -# a workaround for what seems like a bug in Downloads.jl/LibCURL. -if haskey(ENV, "CI") - run(`killall kubectl`) - sleep(5) -end \ No newline at end of file diff --git a/test/simpleapi.jl b/test/simpleapi.jl new file mode 100644 index 00000000..1e2b28c4 --- /dev/null +++ b/test/simpleapi.jl @@ -0,0 +1,243 @@ +# Offline checks on src/simpleapi.jl: resolution, kwarg translation, event +# decoding, and the watch-abort semantics of Kuber #67. No cluster needed. +using Kuber, JSON, Test + +const R = Kuber.ApiImpl +const Runtime = Kuber.Runtime + +@testset "simpleapi" begin + @testset "sel" begin + @test sel("name", :exists) == "name" + @test sel("name", :in, "a", "b") == "name in (a,b)" + @test sel("a in (x)", "b notin (y)") == "a in (x), b notin (y)" + end + + @testset "kwarg translation" begin + # snake_case to the generated lowercase names + @test Kuber._op_kwargs((label_selector = "a=b",)) == (labelselector = "a=b",) + @test Kuber._op_kwargs((resource_version = "42",)) == (resourceversion = "42",) + @test Kuber._op_kwargs((tail_lines = 5,)) == (taillines = 5,) + # already-lowercase names pass through + @test Kuber._op_kwargs((labelselector = "a=b",)) == (labelselector = "a=b",) + # `nothing` is dropped, not forwarded: generated optionals are + # Union{Absent,T}, so an explicit nothing would fail request validation + @test Kuber._op_kwargs((label_selector = nothing, limit = 5)) == (limit = 5,) + @test Kuber._op_kwargs((;)) == NamedTuple() + end + + @testset "scope resolution" begin + @test Kuber._scopes("default") == (:namespaced, :cluster, :allns) + @test Kuber._scopes("*") == (:allns, :cluster) + @test Kuber._scopes(nothing) == (:cluster, :allns) + @test Kuber._scopes("") == (:cluster, :allns) + + core = R.GROUP_MODULES["v1"] + # namespaced kinds resolve namespaced + key, f, params, scope = Kuber._find_op(core, :list, :Pod, "default") + @test scope === :namespaced + @test f === core.listcorev1namespacedpod + @test params == [:namespace] + # and fall back to all-namespaces for "*" + @test Kuber._find_op(core, :list, :Pod, "*")[4] === :allns + # a cluster-scoped kind falls back even though ctx.namespace looks set: + # this is why `get(ctx, :Namespace, "default")` works without a kwarg + @test Kuber._find_op(core, :get, :Namespace, "default")[4] === :cluster + @test Kuber._find_op(core, :list, :Node, "default")[4] === :cluster + # a missing verb is a clean error, not a reflective guess + @test_throws ArgumentError Kuber._find_op(core, :create, :ComponentStatus, "default") + @test_throws ArgumentError Kuber._find_op(core, :list, :NoSuchKind, "default") + end + + @testset "positional arguments follow the spec's path order" begin + # the namespace comes FIRST, the reverse of the old client + @test Kuber._positional([:namespace, :name], "ns", "nm", nothing) == ["ns", "nm"] + @test Kuber._positional([:name], nothing, "nm", nothing) == ["nm"] + @test Kuber._positional(Symbol[], nothing, nothing, nothing) == [] + @test Kuber._positional([:namespace, :body], "ns", nothing, :payload) == ["ns", :payload] + @test_throws ArgumentError Kuber._positional([:namespace], nothing, nothing, nothing) + @test_throws ArgumentError Kuber._positional([:name], nothing, nothing, nothing) + @test_throws ArgumentError Kuber._positional([:body], nothing, nothing, nothing) + + # Everything the apiserver serves calls its object parameter `name`, but + # a group Kuber does not ship need not — custom.metrics.k8s.io's path is + # /namespaces/{namespace}/{compositemetricname}. The name argument fills + # whichever single non-namespace parameter there is. + @test Kuber._positional([:namespace, :compositemetricname], "ns", "pods/*/rps", nothing) == + ["ns", "pods/*/rps"] + @test_throws ArgumentError Kuber._positional([:compositemetricname], nothing, nothing, nothing) + @test Kuber._takes_name([:namespace, :compositemetricname]) + @test !Kuber._takes_name([:namespace]) + @test !Kuber._takes_name([:namespace, :body]) + # …but two of them cannot be addressed positionally at all + @test_throws ArgumentError Kuber._positional([:name, :other], nothing, "x", nothing) + end + + @testset "custom metrics composite names" begin + # custom.metrics.k8s.io addresses a metric by a composite path segment + # rather than by a resource name. The helpers only build that segment; + # exercising the call end to end needs a cluster running an adapter, so + # what is pinned here is the naming, which is what master's helpers were. + @test Kuber._composite_metric_name("http_requests") == "metrics/http_requests" + @test Kuber._composite_metric_name("pods", "http_requests") == "pods/*/http_requests" + @test Kuber._composite_metric_name("pods", "web-1", "http_requests") == + "pods/web-1/http_requests" + + # They route through the verb layer now instead of erroring outright, so + # an unregistered group is reported as one. + ctx = KuberContext() + ctx.initialized = true + for call in (() -> list_namespaced_custom_metrics(ctx, "http_requests"), + () -> list_namespaced_custom_metrics(ctx, "pods", "http_requests"), + () -> list_namespaced_custom_metrics(ctx, "pods", "web-1", "http_requests"), + () -> list_custom_metrics(ctx, "nodes", "cpu"), + () -> list_custom_metrics(ctx, "nodes", "node-1", "cpu")) + e = try + call() + catch ex + ex + end + @test e isa ArgumentError + @test occursin("MetricValue", e.msg) + end + end + + @testset "a name is refused where the operation takes none" begin + ctx = KuberContext() + ctx.initialized = true + ctx.modelapi[:Pod] = R.GROUP_MODULES["v1"] + @test_throws ArgumentError list(ctx, :Pod, "somepod") + end + + @testset "patch bodies are typed per media type" begin + # k8s documents one object schema for all five patch media types, which + # is untrue of json-patch — its body is an array of RFC 6902 operations. + # patch_k8s_spec.jq §6 corrects the document, and this is what the + # correction has to look like by the time `update!` reads it. + apps = R.GROUP_MODULES["apps/v1"] + media = R.OP_BODIES[(apps, :patch, :Deployment, :namespaced)] + @test length(media) == 5 + jsonpatch = media["application/json-patch+json"] + merge = media["application/merge-patch+json"] + @test jsonpatch <: AbstractVector + @test !(merge <: AbstractVector) + @test merge === media["application/strategic-merge-patch+json"] + @test merge === media["application/apply-patch+yaml"] + @test merge === media["application/apply-patch+cbor"] + + # a json-patch array decodes into the array body type… + ops = [Dict{String,Any}("op" => "replace", "path" => "/spec/replicas", "value" => 2)] + decoded = Runtime._decode(jsonpatch, ops, false) + @test decoded isa jsonpatch + @test length(decoded) == 1 + @test decoded[1].additional_properties["path"] == "/spec/replicas" + # …a nested value survives (JuliaRun's taint patch shape) + taint = [Dict{String,Any}("op" => "replace", "path" => "/spec/taints", + "value" => [Dict("key" => "k", "effect" => "NoSchedule")])] + @test Runtime._decode(jsonpatch, taint, false)[1].additional_properties["value"][1]["key"] == "k" + # …and the object model still refuses one, which is the break this fixes + @test_throws Runtime.DecodeError Runtime._decode(merge, ops, false) + + # a merge patch stays an object + @test Runtime._decode(merge, Dict("spec" => Dict("replicas" => 2)), false) isa merge + + ctx = KuberContext() + ctx.initialized = true + ctx.modelapi[:Deployment] = apps + e = try + update!(ctx, :Deployment, "d", Dict("spec" => Dict()), "application/json") + catch ex + ex + end + @test e isa ArgumentError + @test occursin("unsupported patch type", e.msg) + # the message lists what the API does document, in a stable order + @test occursin("application/apply-patch+cbor, application/apply-patch+yaml", e.msg) + end + + @testset "module resolution" begin + ctx = KuberContext() + ctx.initialized = true # pretend discovery ran + ctx.modelapi[:Pod] = R.GROUP_MODULES["v1"] + @test Kuber._resolve_module(ctx, :Pod, nothing) === R.GROUP_MODULES["v1"] + @test Kuber._resolve_module(ctx, :Pod, "apps/v1") === R.GROUP_MODULES["apps/v1"] + @test_throws ArgumentError Kuber._resolve_module(ctx, :Pod, "batch/v1beta1") + @test_throws ArgumentError Kuber._resolve_module(ctx, :Unknown, nothing) + end + + @testset "watch frame decoding" begin + frame = JSON.parse("""{"type": "ADDED", "object": {"kind": "Pod", "apiVersion": "v1", + "metadata": {"name": "p1", "namespace": "default", "resourceVersion": "1234"}, + "spec": {"containers": [{"name": "c", "image": "busybox"}]}}}""") + event = Kuber._to_event(frame) + @test event isa KuberEvent + @test event.type == "ADDED" + @test event.object isa R.KIND_TYPES[("v1", "Pod")] + @test event.object.metadata.name == "p1" + # the generated field is lowercase + @test Kuber._resource_version(event.object) == "1234" + + # an unknown kind is handed back raw rather than throwing + unknown = Kuber._to_event(Dict("type" => "ADDED", + "object" => Dict("kind" => "Widget", "apiVersion" => "example.com/v1"))) + @test unknown.type == "ADDED" + @test unknown.object isa AbstractDict + + # an ERROR frame carrying an expired-resourceVersion Status: what k8s + # actually answers instead of an HTTP 410 + expired = Kuber._to_event(JSON.parse("""{"type": "ERROR", "object": {"kind": "Status", + "apiVersion": "v1", "status": "Failure", "message": "too old resource version", + "reason": "Expired", "code": 410}}""")) + @test expired.type == "ERROR" + @test Kuber._status_code(expired.object) == 410 + @test Kuber._status_code(Dict("code" => 410)) == 410 + @test Kuber._status_code(Dict{String,Any}()) === nothing + end + + @testset "resource version extraction" begin + @test Kuber._resource_version(Dict("metadata" => Dict("resourceVersion" => "7"))) == "7" + @test Kuber._resource_version(Dict("metadata" => Dict())) === nothing + @test Kuber._resource_version(Dict{String,Any}()) === nothing + list = kuber_obj("""{"kind": "PodList", "apiVersion": "v1", + "metadata": {"resourceVersion": "99"}, "items": []}""") + @test Kuber._resource_version(list) == "99" + # ABSENT metadata must not throw + @test Kuber._resource_version(kuber_obj("""{"kind":"Pod","apiVersion":"v1"}""")) === nothing + end + + @testset "typed result from an untyped delete response" begin + raw = JSON.parse("""{"kind": "Status", "apiVersion": "v1", "status": "Success", "code": 200}""") + typed = Kuber._typed_result(raw) + @test typed isa R.KIND_TYPES[("v1", "Status")] + @test kuber_kind(typed) == "Status" + # unknown kinds and non-objects pass through untouched + @test Kuber._typed_result(Dict("kind" => "Widget", "apiVersion" => "x/v1")) isa AbstractDict + @test Kuber._typed_result("plain text") == "plain text" + @test Kuber._typed_result(nothing) === nothing + end + + @testset "watch processor failure aborts the watch" begin + # A `streamprocessor` that throws must abort the watch promptly and + # propagate the error (Kuber #67). Before the fix the processor task died + # silently while `@sync` kept waiting on the long-running watched task — + # a deaf watch: events kept buffering with no error surfaced until the + # server dropped the connection. + ctx = KuberContext() # only passed through to KuberWatchContext; no server needed + producer = (watchctx) -> begin + # mimic the watch pump: keep streaming until the stream is closed + # under it (put! on a closed channel throws) + i = 0 + while true + put!(watchctx.stream, (i += 1)) + sleep(0.05) + end + end + t0 = time() + @test_throws Exception watch(ctx, producer) do stream + take!(stream) + error("processor failure") + end + # must fail fast — processor death closes the stream, which kills the + # producer's next put! — not linger until the producer would have ended + @test (time() - t0) < 10.0 + end +end diff --git a/test/watch_latency.jl b/test/watch_latency.jl new file mode 100644 index 00000000..4d672546 --- /dev/null +++ b/test/watch_latency.jl @@ -0,0 +1,336 @@ +# Watch reaction-time probe for Kuber.jl. +# +# Starts a watch on pods (filtered by a label selector), then on a separate +# task repeatedly creates a pod, patches it, and deletes it, measuring how +# long the watcher takes to see the corresponding ADDED / MODIFIED / DELETED +# events. Prints a per-iteration table and a summary at the end, highlighting +# abnormal delays and missed events. +# +# Usage: +# julia --project test/watch_latency.jl [iterations] # default 20 +# +# Needs an API server reachable at $KUBER_SERVER (default http://localhost:8001). +# If nothing is listening there and `kubectl` is available (e.g. pointing at a +# local k3s cluster), a `kubectl proxy` is started automatically and killed on +# exit. Pods are created in $KUBER_TEST_NAMESPACE (default "default") and +# cleaned up at the end. +# +# Environment variables: +# KUBER_SERVER API server / proxy URL (default http://localhost:8001) +# KUBER_TEST_NAMESPACE namespace for the test pods (default "default") +# KUBER_EVENT_TIMEOUT seconds to wait for a watch event (default 30) +# KUBER_WATCH_DEBUG=1 dump every observed watch event with arrival times + +using Kuber +using HTTP +using Random + + +const SERVER = get(ENV, "KUBER_SERVER", "http://localhost:8001") +const NAMESPACE = get(ENV, "KUBER_TEST_NAMESPACE", "default") +const NITER = isempty(ARGS) ? 20 : parse(Int, ARGS[1]) +const LABEL = "kuber-watch-latency" +const SEQ_ANNOTATION = "kuber-watch-latency-seq" +# seconds to wait for a watch event before declaring it missed (env-overridable) +const EVENT_TIMEOUT = parse(Float64, get(ENV, "KUBER_EVENT_TIMEOUT", "30")) +const RUNID = lowercase(randstring(4)) +# There is one HTTP backend now (HTTP.jl 2.x). What this probe still checks is +# that Kuber's watch wrapper adds no buffering of its own on top of the runtime: +# upstream delivers small chunks incrementally (verified 0.0 s first-item latency +# while the server stalls), and a regression here would show up as MISSED or +# abnormal reactions. +const DEBUG = get(ENV, "KUBER_WATCH_DEBUG", "0") == "1" +const T0_RUN = Ref(0.0) + +# --------------------------------------------------------------------------- +# server / proxy setup + +function server_reachable(url) + try + resp = HTTP.get(url * "/version"; status_exception=false, request_timeout=3) + resp.status == 200 + catch + false + end +end + +function ensure_server() + server_reachable(SERVER) && return + @info("$SERVER not reachable, starting `kubectl proxy`...") + port = something(tryparse(Int, last(split(SERVER, ':'))), 8001) + proc = run(pipeline(`kubectl proxy --port=$port`; stdout=devnull, stderr=devnull); wait=false) + atexit(() -> process_running(proc) && kill(proc)) + deadline = time() + 15 + while time() < deadline && !server_reachable(SERVER) + sleep(0.5) + end + server_reachable(SERVER) || error("cannot reach $SERVER even after starting kubectl proxy; is the cluster up?") +end + +function new_ctx(; timeout=nothing) + ctx = KuberContext() + set_server(ctx, SERVER) + set_ns(ctx, NAMESPACE) + set_retries(ctx; count=3, all_apis=false) + Kuber.set_api_versions!(ctx; verbose=false) + timeout === nothing || Kuber.set_timeout(ctx, timeout) + ctx +end + +# --------------------------------------------------------------------------- +# watcher: record every pod watch event with its arrival time + +const SIGHTINGS = NamedTuple{(:t, :type, :name, :seq),Tuple{Float64,String,String,String}}[] +const LCK = ReentrantLock() +const WATCH_STARTED = Ref(false) + +snapshot() = lock(() -> length(SIGHTINGS), LCK) + +function start_watcher() + # No per-request deadline is needed: a watch never carries `request_timeout`. + wctx = new_ctx() + stream_ref = Ref{Any}(nothing) + task = @async watch(wctx, list, :Pod; label_selector="$LABEL=$RUNID") do stream + stream_ref[] = stream + for event in stream + t = time() + WATCH_STARTED[] = true + isa(event, KuberEvent) || continue # skip the initial PodList + # `event.object` is already the typed model — no kuber_obj needed — + # and its optional fields may be ABSENT rather than nothing. + obj = event.object + name = try string(obj.metadata.name) catch; "" end + # labels and annotations are open objects: kuber_props reads them + seq = try string(kuber_props(obj.metadata.annotations)[SEQ_ANNOTATION]) catch; "" end + lock(LCK) do + push!(SIGHTINGS, (t=t, type=string(event.type), name=name, seq=seq)) + end + end + end + task, stream_ref +end + +# wait until a sighting past index `start_idx` matches `pred`; returns the +# sighting (with its arrival timestamp) or `nothing` on timeout +function wait_for_sighting(pred::Function, start_idx::Int; timeout=EVENT_TIMEOUT) + deadline = time() + timeout + while time() < deadline + found = lock(LCK) do + idx = findnext(pred, SIGHTINGS, start_idx + 1) + idx === nothing ? nothing : SIGHTINGS[idx] + end + found === nothing || return found + sleep(0.002) + end + nothing +end + +# --------------------------------------------------------------------------- +# driver: create / update / delete pods and time the watcher's reaction + +pod_json(name) = """{ + "kind": "Pod", + "apiVersion": "v1", + "metadata": { + "name": "$name", + "namespace": "$NAMESPACE", + "labels": {"$LABEL": "$RUNID"} + }, + "spec": { + "terminationGracePeriodSeconds": 0, + "containers": [{ + "name": "main", + "image": "busybox:stable", + "command": ["sh", "-c", "sleep 3600"] + }] + } +}""" + +# one measurement: run `action`, then wait for the matching watch event; +# returns (api call duration, reaction time from action start to event arrival) +function timed_op(action::Function, pred::Function) + start_idx = snapshot() + t0 = time() + action() + api = time() - t0 + s = wait_for_sighting(pred, start_idx) + react = s === nothing ? missing : s.t - t0 + api, react +end + +function run_iteration(ctx, i) + name = "watch-latency-$RUNID-$i" + pod = kuber_obj(pod_json(name)) + + create_api, create_react = timed_op( + () -> put!(ctx, pod), + e -> e.type == "ADDED" && e.name == name) + + patch = Dict("metadata" => Dict("annotations" => Dict(SEQ_ANNOTATION => string(i)))) + update_api, update_react = timed_op( + () -> update!(ctx, :Pod, name, patch, "application/merge-patch+json"), + e -> e.type == "MODIFIED" && e.name == name && e.seq == string(i)) + + delete_api, delete_react = timed_op( + () -> delete!(ctx, :Pod, name; grace_period_seconds=0), + e -> e.type == "DELETED" && e.name == name) + + (iter=i, create_api=create_api, create_react=create_react, + update_api=update_api, update_react=update_react, + delete_api=delete_api, delete_react=delete_react) +end + +function cleanup(ctx) + try + pods = get(ctx, :Pod; label_selector="$LABEL=$RUNID") + for item in pods.items + try + delete!(ctx, :Pod, item.metadata.name; grace_period_seconds=0) + catch ex + @warn("failed to delete leftover pod", pod=item.metadata.name, exception=ex) + end + end + catch ex + @warn("cleanup failed", exception=ex) + end +end + +# --------------------------------------------------------------------------- +# reporting + +fmt_ms(x) = x === missing ? "MISSED" : string(round(x * 1000; digits=1)) + +function med(v) + isempty(v) && return NaN + s = sort(v) + n = length(s) + isodd(n) ? s[(n + 1) ÷ 2] : (s[n ÷ 2] + s[n ÷ 2 + 1]) / 2 +end + +pctl(v, p) = isempty(v) ? NaN : sort(v)[clamp(ceil(Int, p * length(v)), 1, length(v))] + +# an op is abnormal if the event never arrived, or its reaction time exceeds +# max(500ms, 3x the median for that op type) +abnormal_threshold(m) = max(0.5, 3 * m) +is_abnormal(react, m) = react === missing || react > abnormal_threshold(m) + +function report(results) + ops = [(:create_react, "create"), (:update_react, "update"), (:delete_react, "delete")] + medians = Dict(op => med([r[op] for r in results if r[op] !== missing]) for (op, _) in ops) + + println() + println("="^78) + println(" Watch reaction-time report — $(length(results)) iterations against $SERVER") + println(" (api = API call duration, react = action start -> watch event arrival, ms)") + println("="^78) + hdr = string(lpad("iter", 5), " |", + lpad("create api", 11), lpad("react", 9), " |", + lpad("update api", 11), lpad("react", 9), " |", + lpad("delete api", 11), lpad("react", 9)) + println(hdr) + println("-"^length(hdr)) + abnormalities = String[] + for r in results + flags = String[] + for (op, opname) in ops + is_abnormal(r[op], medians[op]) && push!(flags, opname) + end + line = string(lpad(r.iter, 5), " |", + lpad(fmt_ms(r.create_api), 11), lpad(fmt_ms(r.create_react), 9), " |", + lpad(fmt_ms(r.update_api), 11), lpad(fmt_ms(r.update_react), 9), " |", + lpad(fmt_ms(r.delete_api), 11), lpad(fmt_ms(r.delete_react), 9)) + if !isempty(flags) + line *= " ⚠ SLOW: " * join(flags, ", ") + for (op, opname) in ops + if r[op] === missing + push!(abnormalities, "iter $(r.iter) $opname: watch event never arrived (waited $(EVENT_TIMEOUT)s)") + elseif is_abnormal(r[op], medians[op]) + push!(abnormalities, "iter $(r.iter) $opname: react=$(fmt_ms(r[op]))ms " * + "(threshold $(fmt_ms(abnormal_threshold(medians[op])))ms, median $(fmt_ms(medians[op]))ms)") + end + end + end + println(line) + end + + println() + println(" Summary (watcher reaction time, ms)") + println(string(lpad("op", 8), lpad("ok", 5), lpad("missed", 8), + lpad("min", 9), lpad("median", 9), lpad("mean", 9), lpad("p95", 9), lpad("max", 9))) + for (op, opname) in ops + vals = [Float64(r[op]) for r in results if r[op] !== missing] + nmissed = count(r -> r[op] === missing, results) + if isempty(vals) + println(string(lpad(opname, 8), lpad(0, 5), lpad(nmissed, 8), " (no events received!)")) + else + println(string(lpad(opname, 8), lpad(length(vals), 5), lpad(nmissed, 8), + lpad(fmt_ms(minimum(vals)), 9), lpad(fmt_ms(med(vals)), 9), + lpad(fmt_ms(sum(vals) / length(vals)), 9), + lpad(fmt_ms(pctl(vals, 0.95)), 9), lpad(fmt_ms(maximum(vals)), 9))) + end + end + + println() + if isempty(abnormalities) + println(" No abnormal delays detected ✓") + else + println(" ⚠ ABNORMAL DELAYS ($(length(abnormalities))):") + for a in abnormalities + println(" - ", a) + end + end + println("="^78) +end + +# --------------------------------------------------------------------------- +# main + +function main() + T0_RUN[] = time() + ensure_server() + + @info("initializing contexts against $SERVER (namespace $NAMESPACE, run id $RUNID)") + ctx = new_ctx() + + @info("starting pod watcher (label selector $LABEL=$RUNID)") + watch_task, stream_ref = start_watcher() + timedwait(() -> WATCH_STARTED[] || istaskfailed(watch_task), 30.0; pollint=0.1) + istaskfailed(watch_task) && fetch(watch_task) # rethrow the watcher's error + WATCH_STARTED[] || error("watcher did not start within 30s") + @info("watcher ready") + + results = Any[] + try + for i in 1:NITER + r = run_iteration(ctx, i) + missed = [n for n in (:create_react, :update_react, :delete_react) if r[n] === missing] + @info("iteration $i/$NITER done", create="$(fmt_ms(r.create_react))ms", + update="$(fmt_ms(r.update_react))ms", delete="$(fmt_ms(r.delete_react))ms", + missed=isempty(missed) ? "none" : join(missed, ",")) + push!(results, r) + sleep(0.2) # let residual events (status updates etc.) drain between iterations + end + finally + cleanup(ctx) + # closing the stream aborts the watch HTTP request and ends the watcher task + stream_ref[] === nothing || close(stream_ref[]) + try + timedwait(() -> istaskdone(watch_task), 10.0; pollint=0.2) + catch + end + end + + if DEBUG + println("\n--- all watch events seen (t is seconds since run start) ---") + lock(LCK) do + for s in SIGHTINGS + println(" t=", round(s.t - T0_RUN[]; digits=3), "s ", rpad(s.type, 9), " ", s.name, + isempty(s.seq) ? "" : " seq=$(s.seq)") + end + end + end + + isempty(results) || report(results) +end + +main() diff --git a/test/watch_longevity.jl b/test/watch_longevity.jl new file mode 100644 index 00000000..eeb60f06 --- /dev/null +++ b/test/watch_longevity.jl @@ -0,0 +1,378 @@ +# Long-lived watch probe for Kuber.jl — G5b in OpenAPIv1ConsumerGaps.md. +# +# G5a covers everything about a long-lived watch that compression can reach: a +# server-initiated close is `timeoutseconds` away, so `test/runtests.jl` proves +# re-establishment, bookmarks and resync in about twelve seconds. What is left +# needs real time and a real network — this probe — and is why it is not a CI +# job: +# +# - does a watch left alone for hours keep delivering? The apiserver ends one +# on its own timer (`--min-request-timeout`, 1800 s by default, randomized +# into [1800, 3600)), so a run of a few hours crosses several closes that +# nothing asked for +# - does anything grow? File descriptors and memory across dozens of silent +# re-establishments are exactly what a short test cannot see +# - does an intermediary drop it? A load balancer's idle timeout (60–350 s on +# the common cloud balancers) only exists where there is a load balancer. +# Run this *through* whatever proxy or LB the deployment has, not against a +# local apiserver, or it cannot answer that question at all +# +# Reconnects are not directly observable — Kuber re-establishes silently, which +# is the point of it — so the probe measures the thing that actually matters +# instead: every heartbeat it touches an object and times how long the watcher +# takes to see it. A missed heartbeat means the watch stopped working, whatever +# the cause. Resyncs *are* observable, as a list frame on the stream, and are +# counted separately. +# +# Usage: +# julia --project test/watch_longevity.jl [hours] # default 2 +# +# Needs an API server reachable at $KUBER_SERVER (default http://localhost:8001). +# If nothing is listening there and `kubectl` is available, a `kubectl proxy` is +# started automatically and killed on exit. Pods are created in +# $KUBER_TEST_NAMESPACE (default "default") and cleaned up at the end. +# +# Environment variables: +# KUBER_SERVER API server / proxy URL (default http://localhost:8001) +# KUBER_TEST_NAMESPACE namespace for the probe pods (default "default") +# KUBER_HEARTBEAT seconds between heartbeats (default 300) +# KUBER_EVENT_TIMEOUT seconds to wait for an event (default 60) +# +# A note on the growth numbers: a Julia process grows for its own reasons early +# on — compilation, first-call allocation — so the report takes its baseline +# from the *second* sample and flags sustained growth rather than any growth. +# Treat it as a signal to look closer, not as a leak detector. + +using Kuber +using HTTP +using Random +using Printf + +const SERVER = get(ENV, "KUBER_SERVER", "http://localhost:8001") +const NAMESPACE = get(ENV, "KUBER_TEST_NAMESPACE", "default") +const HOURS = isempty(ARGS) ? 2.0 : parse(Float64, ARGS[1]) +const HEARTBEAT = parse(Float64, get(ENV, "KUBER_HEARTBEAT", "300")) +const EVENT_TIMEOUT = parse(Float64, get(ENV, "KUBER_EVENT_TIMEOUT", "60")) +const LABEL = "kuber-watch-longevity" +const RUNID = lowercase(randstring(4)) + +# --------------------------------------------------------------------------- +# server / proxy setup — same shape as test/watch_latency.jl + +function server_reachable(url) + try + resp = HTTP.get(url * "/version"; status_exception = false, request_timeout = 3) + resp.status == 200 + catch + false + end +end + +function ensure_server() + server_reachable(SERVER) && return + @info("$SERVER not reachable, starting `kubectl proxy`...") + port = something(tryparse(Int, last(split(SERVER, ':'))), 8001) + proc = run(pipeline(`kubectl proxy --port=$port`; stdout = devnull, stderr = devnull); wait = false) + atexit(() -> process_running(proc) && kill(proc)) + deadline = time() + 15 + while time() < deadline && !server_reachable(SERVER) + sleep(0.5) + end + server_reachable(SERVER) || + error("cannot reach $SERVER even after starting kubectl proxy; is the cluster up?") +end + +function new_ctx() + ctx = KuberContext() + set_server(ctx, SERVER) + set_ns(ctx, NAMESPACE) + set_retries(ctx; count = 3, all_apis = false) + Kuber.set_api_versions!(ctx; verbose = false) + ctx +end + +# --------------------------------------------------------------------------- +# process metrics. Linux-only via /proc; elsewhere the columns read as missing +# rather than the probe refusing to run, since liveness is the primary question. + +function open_fds() + try + length(readdir("/proc/self/fd")) + catch + missing + end +end + +function rss_mb() + try + # `readlines`, not `eachline`: returning early out of an `eachline` loop + # leaves the stream open, so this function would leak one descriptor per + # call — and it is the function reporting descriptor counts. The first + # run of this probe "found" exactly that, growing one fd per heartbeat + # with the leak entirely in the instrument. + for line in readlines("/proc/self/status") + startswith(line, "VmRSS:") || continue + return parse(Float64, split(line)[2]) / 1024 + end + missing + catch + missing + end +end + +# A full collection first, so this reports memory still reachable rather than +# memory not yet collected. Without it the number tracks GC timing — it rose +# 61 MB across one two-minute run and fell 98 MB across the next — and a growth +# check on top of that is noise. A collection per heartbeat is nothing against a +# five-minute interval. +live_mb() = (GC.gc(); Base.gc_live_bytes() / 1024^2) + +# --------------------------------------------------------------------------- +# watcher + +const SIGHTINGS = NamedTuple{(:t, :type, :name),Tuple{Float64,String,String}}[] +const LCK = ReentrantLock() +const STARTED = Ref(false) +const RESYNCS = Ref(0) # a list frame after the first means a 410 resync +const BOOKMARKS = Ref(0) +const FRAMES = Ref(0) + +snapshot() = lock(() -> length(SIGHTINGS), LCK) + +function start_watcher() + wctx = new_ctx() + stream_ref = Ref{Any}(nothing) + task = @async watch(wctx, list, :Pod; + label_selector = "$LABEL=$RUNID", + allow_watch_bookmarks = true) do stream + stream_ref[] = stream + for event in stream + t = time() + lock(LCK) do + FRAMES[] += 1 + if !isa(event, KuberEvent) + # the initial typed List, and every resync list after it + STARTED[] ? (RESYNCS[] += 1) : (STARTED[] = true) + return + end + event.type == "BOOKMARK" && (BOOKMARKS[] += 1) + name = try + string(Kuber._field(event.object.metadata.name)) + catch + "" + end + push!(SIGHTINGS, (t = t, type = string(event.type), name = name)) + end + end + end + task, stream_ref +end + +function wait_for_sighting(pred::Function, start_idx::Int; timeout = EVENT_TIMEOUT) + deadline = time() + timeout + while time() < deadline + found = lock(LCK) do + idx = findnext(pred, SIGHTINGS, start_idx + 1) + idx === nothing ? nothing : SIGHTINGS[idx] + end + found === nothing || return found + sleep(0.05) + end + nothing +end + +# --------------------------------------------------------------------------- +# heartbeat: create a pod, wait to hear about it, delete it + +pod_json(name) = """{ + "kind": "Pod", + "apiVersion": "v1", + "metadata": { + "name": "$name", + "namespace": "$NAMESPACE", + "labels": {"$LABEL": "$RUNID"} + }, + "spec": { + "terminationGracePeriodSeconds": 0, + "containers": [{ + "name": "main", + "image": "busybox:stable", + "command": ["sh", "-c", "sleep 3600"] + }] + } +}""" + +function heartbeat(ctx, i) + name = "watch-longevity-$RUNID-$i" + start_idx = snapshot() + t0 = time() + reaction = missing + err = nothing + try + put!(ctx, kuber_obj(pod_json(name))) + s = wait_for_sighting(e -> e.type == "ADDED" && e.name == name, start_idx) + reaction = s === nothing ? missing : s.t - t0 + catch ex + err = ex + finally + try + delete!(ctx, :Pod, name; grace_period_seconds = 0) + catch + end + end + # Sampled outside the lock: `live_mb` runs a full collection, and the + # watcher task should not wait on it. + fds, rss, live = open_fds(), rss_mb(), live_mb() + lock(LCK) do + (beat = i, t = t0, reaction = reaction, err = err, + events = length(SIGHTINGS), bookmarks = BOOKMARKS[], resyncs = RESYNCS[], + fds = fds, rss = rss, live = live) + end +end + +function cleanup(ctx) + try + pods = get(ctx, :Pod; label_selector = "$LABEL=$RUNID") + for item in pods.items + try + delete!(ctx, :Pod, Kuber._field(item.metadata.name); grace_period_seconds = 0) + catch ex + @warn("failed to delete leftover pod", exception = ex) + end + end + catch ex + @warn("cleanup failed", exception = ex) + end +end + +# --------------------------------------------------------------------------- +# reporting + +fmt(x::Missing, _) = "-" +fmt(x, digits) = string(round(x; digits = digits)) +fmt_int(x) = x === missing ? "-" : string(x) +fmt_ms(x) = x === missing ? "MISSED" : string(round(x * 1000; digits = 1)) + +function report(samples, t_start) + println() + println("="^92) + @printf(" Long-lived watch probe — %.2f h against %s (namespace %s, run %s)\n", + (time() - t_start) / 3600, SERVER, NAMESPACE, RUNID) + println(" A missed heartbeat means the watch stopped delivering, however it stopped.") + println("="^92) + hdr = string(lpad("beat", 5), lpad("elapsed", 10), lpad("react ms", 11), + lpad("events", 9), lpad("bookmk", 8), lpad("resync", 8), + lpad("fds", 7), lpad("rss MB", 10), lpad("live MB", 10)) + println(hdr) + println("-"^length(hdr)) + for s in samples + line = string(lpad(s.beat, 5), + lpad(string(round((s.t - t_start) / 60; digits = 1), "m"), 10), + lpad(fmt_ms(s.reaction), 11), + lpad(s.events, 9), lpad(s.bookmarks, 8), lpad(s.resyncs, 8), + lpad(fmt_int(s.fds), 7), lpad(fmt(s.rss, 1), 10), + lpad(fmt(s.live, 1), 10)) + s.reaction === missing && (line *= " ⚠ MISSED") + s.err === nothing || (line *= " ⚠ ERROR: " * sprint(showerror, s.err)) + println(line) + end + + missed = count(s -> s.reaction === missing, samples) + errored = count(s -> s.err !== nothing, samples) + println() + println(" Heartbeats: $(length(samples)), missed $missed, errored $errored") + if !isempty(samples) + last = samples[end] + println(" Resyncs (410 -> fresh list): $(last.resyncs); bookmarks: $(last.bookmarks);" * + " events: $(last.events)") + end + + # Growth is measured from the second sample: the first carries the process's + # own warm-up, which is not what this is looking for. + if length(samples) >= 3 + base, fin = samples[2], samples[end] + span = (fin.t - base.t) / 3600 + println() + println(" Growth from beat $(base.beat) to $(fin.beat) (over $(round(span; digits=2)) h)") + for (name, a, b, unit) in (("open fds", base.fds, fin.fds, ""), + ("rss", base.rss, fin.rss, " MB"), + ("gc live", base.live, fin.live, " MB")) + if a === missing || b === missing + println(" ", rpad(name, 10), " unavailable on this platform") + continue + end + delta = b - a + flag = (a > 0 && delta > 0.25 * a) ? " ⚠ look closer" : "" + # A per-hour rate off a short span is noise pretending to be a trend. + rate = span >= 0.25 ? @sprintf(", %+.1f%s/h", delta / span, unit) : "" + @printf(" %-10s %8.1f -> %8.1f%s (%+.1f%s%s)%s\n", + name, a, b, unit, delta, unit, rate, flag) + end + end + + println() + if missed == 0 && errored == 0 + println(" The watch delivered every heartbeat for the whole run ✓") + else + println(" ⚠ The watch missed $missed heartbeat(s) and errored on $errored.") + println(" Re-run with KUBER_HEARTBEAT smaller to narrow when it stopped.") + end + println("="^92) +end + +# --------------------------------------------------------------------------- + +function main() + ensure_server() + @info("long-lived watch probe", hours = HOURS, heartbeat_s = HEARTBEAT, + server = SERVER, namespace = NAMESPACE, runid = RUNID) + ctx = new_ctx() + + watch_task, stream_ref = start_watcher() + timedwait(() -> STARTED[] || istaskfailed(watch_task), 30.0; pollint = 0.1) + istaskfailed(watch_task) && fetch(watch_task) + STARTED[] || error("watcher did not start within 30s") + + # One untimed pass first. The first `put!`/`delete!` in a fresh process pays + # for compilation, and a fourteen-second "reaction" that is really codegen + # would otherwise be the most alarming number in the table — or a missed + # heartbeat, under a short KUBER_EVENT_TIMEOUT. + @info("warming up (one untimed heartbeat)") + heartbeat(ctx, 0) + @info("watcher ready; first heartbeat now, then every $(HEARTBEAT)s") + + t_start = time() + deadline = t_start + HOURS * 3600 + samples = Any[] + i = 0 + try + while true + i += 1 + s = heartbeat(ctx, i) + push!(samples, s) + @info("beat $i", elapsed = string(round((time() - t_start) / 60; digits = 1), "m"), + reaction = fmt_ms(s.reaction) * "ms", resyncs = s.resyncs, + bookmarks = s.bookmarks, fds = s.fds, rss = fmt(s.rss, 1)) + if istaskfailed(watch_task) + @error("the watcher task died — the watch did not survive") + fetch(watch_task) + end + time() + HEARTBEAT > deadline && break + sleep(HEARTBEAT) + end + catch ex + ex isa InterruptException || rethrow() + @info("interrupted; reporting what was collected") + finally + cleanup(ctx) + stream_ref[] === nothing || close(stream_ref[]) + try + timedwait(() -> istaskdone(watch_task), 10.0; pollint = 0.2) + catch + end + end + + isempty(samples) || report(samples, t_start) +end + +main() diff --git a/test/watch_recovery.jl b/test/watch_recovery.jl new file mode 100644 index 00000000..3ec439a3 --- /dev/null +++ b/test/watch_recovery.jl @@ -0,0 +1,430 @@ +# Watch recovery semantics: the acceptance criteria of +# OpenAPIv1TrialBranchPlan.md §6 that need failure injection rather than a +# cooperative cluster — a consumer stopping a watch, a connection dropped +# mid-stream (Kuber #68), a truncated item, and an expired resourceVersion. +# +# Driven by a fake apiserver so the failures are deterministic and every +# request's query string can be inspected. Discovery is pre-seeded, so the fake +# server only has to answer the pod list path. +# +# The server is built on HTTP.jl rather than raw TCP on purpose. A hand-rolled +# chunked response is *not* enough: one that curl streams happily still arrives +# at the HTTP.jl client only when the connection closes, which would make these +# tests pass at teardown and prove nothing about streaming. Using the same +# library on both ends keeps the framing beyond question — and the real +# apiserver's framing (Transfer-Encoding: chunked, one event per chunk) is +# already covered live by test/watch_latency.jl. +using Kuber, HTTP, JSON, Test + +const R = Kuber.ApiImpl +const CORE = R.GROUP_MODULES["v1"] + +"""A pod list the strict client will accept.""" +podlist(rv, names = String[]) = JSON.json(Dict("kind" => "PodList", "apiVersion" => "v1", + "metadata" => Dict("resourceVersion" => rv), + "items" => [Dict("kind" => "Pod", "apiVersion" => "v1", + "metadata" => Dict("name" => n, "namespace" => "default", + "resourceVersion" => rv)) for n in names])) + +event(type, name, rv) = JSON.json(Dict("type" => type, + "object" => Dict("kind" => "Pod", "apiVersion" => "v1", + "metadata" => Dict("name" => name, "namespace" => "default", + "resourceVersion" => rv)))) + +"""Write one watch frame and push it out immediately.""" +function frame(http, text) + write(http, text * "\n") + flush(http) +end + +""" + hold(alive) + +Keep a watch response open until the server is stopped. + +Handlers must not simply `sleep` for a long time: `close(server)` waits for +in-flight handlers to return, so a sleeping handler hangs teardown rather than +the test failing. +""" +function hold(alive) + while alive[] + sleep(0.1) + end +end + +""" + fakeapi(watchhandler) -> (url, requests, stop) + +A fake apiserver. Buffered list requests are answered by `listbody(n)`, an empty +`PodList` at resourceVersion 100 unless overridden — `n` is the list request's +number, so a test can make the second list differ from the first. Watch requests +(`watch=true` in the query) are handed to `watchhandler(http, request_number, +alive)`, which writes frames and may truncate the stream or return early to end +it. `requests` accumulates every request target seen. +""" +function fakeapi(watchhandler; listbody = n -> podlist("100")) + requests = String[] + lck = ReentrantLock() + watches = Ref(0) + lists = Ref(0) + alive = Ref(true) + server = HTTP.listen!("127.0.0.1", 0; listenany = true) do http + target = String(http.message.target) + lock(lck) do + push!(requests, target) + end + HTTP.setheader(http, "Content-Type" => "application/json") + if occursin("watch=true", target) + n = lock(() -> (watches[] += 1), lck) + HTTP.startwrite(http) + watchhandler(http, n, alive) + else + body = listbody(lock(() -> (lists[] += 1), lck)) + HTTP.setheader(http, "Content-Length" => string(sizeof(body))) + HTTP.startwrite(http) + write(http, body) + end + end + stop = () -> (alive[] = false; close(server)) + return "http://127.0.0.1:$(HTTP.port(server))", requests, stop +end + +"""A context wired to `url` with discovery pre-seeded (the fake server has none).""" +function fakectx(url) + ctx = KuberContext() + set_server(ctx, url) + set_ns(ctx, "default") + ctx.apis[:Core] = [CORE] + ctx.modelapi[:Pod] = CORE + ctx.initialized = true + return ctx +end + +watchqueries(requests) = filter(t -> occursin("watch=true", t), requests) +listqueries(requests) = filter(t -> !occursin("watch=true", t), requests) + +startwatch(ctx, stream; push_initial = false) = + @async list(Kuber.KuberWatchContext(ctx, stream), :Pod; watch = true, push_initial = push_initial) + +# The first event on a cold process waits for the whole watch and decode path to +# compile; steady state is single-digit ms (test/watch_latency.jl). +const FIRST_EVENT_TIMEOUT = 90.0 + +function take_event(stream, timeout = FIRST_EVENT_TIMEOUT) + @test timedwait(() -> isready(stream), timeout) == :ok + return take!(stream) +end + +@testset "watch recovery" begin + @testset "consumer close stops the watch, even on a silent stream" begin + # The stream goes quiet after one event. Closing it must still end the + # watch promptly rather than waiting for a frame that never comes. + url, requests, stop = fakeapi() do http, n, alive + frame(http, event("ADDED", "p1", "101")) + hold(alive) # silence + end + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + @test take_event(stream) isa KuberEvent + + t0 = time() + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + @test (time() - t0) < 5.0 # not waiting for the next frame + @test !istaskfailed(watcher) + # a stop must not be mistaken for a failure and re-established + @test length(watchqueries(requests)) == 1 + stop() + end + + @testset "dropped connection re-watches from the last resourceVersion" begin + # Kuber #68: a connection dropped mid-watch is retried. On an item + # boundary this looks exactly like a watch ending normally, so the loop + # must re-establish either way — and resume from where it got to. + url, requests, stop = fakeapi() do http, n, alive + if n == 1 + frame(http, event("ADDED", "p1", "101")) + # Returning ends the response; with HTTP.jl on both ends that is + # a *clean* end rather than an abort — which is exactly the case + # that matters, since a real drop on an item boundary is + # indistinguishable from one (a genuine abort is characterized in + # test/characterize_retries.jl). + sleep(0.5) + else + frame(http, event("MODIFIED", "p1", "102")) + hold(alive) + end + end + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + + @test take_event(stream).type == "ADDED" + # only arrives if the watch re-established itself + @test take_event(stream, 30.0).type == "MODIFIED" + + queries = watchqueries(requests) + @test length(queries) >= 2 + @test occursin("resourceVersion=100", queries[1]) # from the initial list + @test occursin("resourceVersion=101", queries[2]) # from the last event seen + + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + stop() + end + + @testset "a caller can end a watch and re-establish it itself" begin + # G2. `K8sReflector.jl:216-245` wraps `Kuber.watch` in its own + # `while true` and relies on `watch` *returning* so it can re-establish + # from a resourceVersion it tracked. Here a watch carries no deadline and + # the pump re-watches internally, so a clean server close — including one + # caused by `timeout_seconds` — never ends the watch. The only thing that + # does is the consumer closing the stream, which a stream processor does + # simply by leaving its event loop. + # + # So the reflector's loop cannot work as written, but the *pattern* is + # still expressible, and this is the shape of it. + url, requests, stop = fakeapi() do http, n, alive + frame(http, event("ADDED", "p$n", "10$n")) + hold(alive) + end + ctx = fakectx(url) + + seen = KuberEvent[] + rv = nothing + driver = @async for _ in 1:2 + # round 1 has nothing to resume from and lists; round 2 resumes + resume = rv === nothing ? NamedTuple() : (; resource_version = rv) + watch(ctx, list, :Pod; resume...) do stream + for item in stream + item isa KuberEvent || continue # the initial list frame + push!(seen, item) + rv = Kuber._resource_version(item.object) + break # leaving the loop closes the stream, which ends + end # the watch — the reflector's re-establish point + end + end + @test timedwait(() -> istaskdone(driver), FIRST_EVENT_TIMEOUT) == :ok + istaskfailed(driver) && @error "the re-establishment loop failed" driver.result + @test !istaskfailed(driver) + + # both rounds ran, and the second resumed where the first stopped + @test length(seen) == 2 + @test Kuber._resource_version(seen[1].object) == "101" + @test Kuber._resource_version(seen[2].object) == "102" + + queries = watchqueries(requests) + @test length(queries) == 2 + @test occursin("resourceVersion=100", queries[1]) # from the initial list + @test occursin("resourceVersion=101", queries[2]) # from the caller + + # …and the resumed round did not list. That is the useful half of the + # `if !watch || resource_version === nothing` guard: a caller that keeps + # its own store pays for the initial state exactly once. (The same guard + # is why `resource_version=` does nothing on a *non-watch* read — G17.) + @test length(listqueries(requests)) == 1 + + stop() + end + + @testset "no event is dropped or duplicated across a re-watch" begin + # G3. The other re-watch tests assert that a resume *happens* with the + # right resourceVersion. This one asserts the property a cache-maintaining + # consumer actually depends on: the event sequence either side of the seam + # is exactly what the server sent, with nothing lost and nothing repeated. + # + # Two things make it a real test rather than a restatement. The first + # watch sends a *burst* and then closes cleanly, so events are in flight + # when the connection ends rather than neatly one per round trip; and the + # consumer does not read anything until the seam has demonstrably passed, + # so the events have to survive buffered across it. + url, requests, stop = fakeapi() do http, n, alive + if n == 1 + for rv in ("101", "102", "103") + frame(http, event("ADDED", "p$rv", rv)) + end + sleep(0.5) # then return: a clean close, mid-sequence + else + for rv in ("104", "105") + frame(http, event("MODIFIED", "p$rv", rv)) + end + hold(alive) + end + end + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + + # wait for the seam itself, not for an event, so nothing is consumed + # until the re-watch has already been established + @test timedwait(() -> length(watchqueries(requests)) >= 2, + FIRST_EVENT_TIMEOUT) == :ok + + events = [take_event(stream, 30.0) for _ in 1:5] + versions = [Kuber._resource_version(e.object) for e in events] + @test versions == ["101", "102", "103", "104", "105"] + @test allunique(versions) + @test [e.type for e in events] == + ["ADDED", "ADDED", "ADDED", "MODIFIED", "MODIFIED"] + # nothing extra is waiting either — a re-delivered frame would show up here + @test !isready(stream) + + queries = watchqueries(requests) + @test length(queries) == 2 + # the resume names the last version delivered, not the first of the burst + @test occursin("resourceVersion=103", queries[2]) + + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + @test !istaskfailed(watcher) + stop() + end + + @testset "truncated item re-watches" begin + # The 1.0 runtime closes the channel with a DecodeError instead of ending + # silently; that is a failure to recover from, not one to surface. + url, requests, stop = fakeapi() do http, n, alive + if n == 1 + frame(http, event("ADDED", "p1", "101")) + sleep(0.5) + write(http, "{\"type\": \"ADDED\", \"object\": {\"kind\": ") # truncated + flush(http) + sleep(0.5) + else + frame(http, event("MODIFIED", "p1", "102")) + hold(alive) + end + end + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + + @test take_event(stream).type == "ADDED" + @test take_event(stream, 30.0).type == "MODIFIED" + @test length(watchqueries(requests)) >= 2 + + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + stop() + end + + # An expired resourceVersion is answered in-stream, with an ERROR event + # carrying a Status(reason=Expired, code=410) under HTTP 200 — not an HTTP + # error. Watching again *without* a resourceVersion would recover the + # connection but not the truth: k8s replays current state as synthetic ADDED + # events, so a consumer hears about everything that still exists and never + # about what was deleted while the watch was gone. Kuber lists again instead, + # and delivers that list as a resync frame (G1 in OpenAPIv1ConsumerGaps.md). + expiredapi(listbody) = fakeapi(; listbody = listbody) do http, n, alive + if n == 1 + frame(http, event("ADDED", "p1", "101")) + sleep(0.5) + frame(http, JSON.json(Dict("type" => "ERROR", + "object" => Dict("kind" => "Status", "apiVersion" => "v1", + "status" => "Failure", "reason" => "Expired", + "message" => "too old resource version", "code" => 410)))) + sleep(0.5) + else + frame(http, event("MODIFIED", "p2", "301")) + hold(alive) + end + end + + # p1 exists at the first list and is gone by the second: exactly the object a + # replay would never mention. + expiredlists(n) = n == 1 ? podlist("100", ["p1"]) : podlist("300", ["p2"]) + + @testset "an expired resourceVersion resyncs from a fresh list" begin + url, requests, stop = expiredapi(expiredlists) + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream; push_initial = true) + + initial = take_event(stream) + @test kuber_kind(initial) == "PodList" + @test Kuber._field(initial.metadata.resourceversion) == "100" + + @test take_event(stream, 30.0).object.metadata.name == "p1" + + # the ERROR frame is not delivered; a fresh list is + resync = take_event(stream, 30.0) + @test kuber_kind(resync) == "PodList" + @test Kuber._field(resync.metadata.resourceversion) == "300" + @test [Kuber._field(p.metadata.name) for p in resync.items] == ["p2"] + + @test take_event(stream, 30.0).type == "MODIFIED" + + @test length(listqueries(requests)) == 2 # it really re-listed + queries = watchqueries(requests) + @test length(queries) >= 2 + @test occursin("resourceVersion=100", queries[1]) # from the initial list + @test occursin("resourceVersion=300", queries[2]) # from the resync list + + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + stop() + end + + @testset "push_initial=false recovers, but is told nothing about the gap" begin + # The events-only form (`watch(ctx, O, stream)`) opts out of list frames, + # so it opts out of the resync too. It still re-lists — that is where the + # resourceVersion to resume from comes from — but a consumer maintaining + # a cache on this form has to track expiry itself. + url, requests, stop = expiredapi(expiredlists) + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + + @test take_event(stream).object.metadata.name == "p1" + next = take_event(stream, 30.0) + @test next isa KuberEvent # no list frame + @test next.type == "MODIFIED" + + @test length(listqueries(requests)) == 2 + @test occursin("resourceVersion=300", watchqueries(requests)[2]) + + close(stream) + @test timedwait(() -> istaskdone(watcher), 15.0) == :ok + stop() + end + + # A connection aborted *mid-chunk* — an apiserver restart or a network drop, + # the one #68 shape a clean end does not stand in for — closes the channel + # with an HTTP.jl error (`ParseError: unexpected EOF while reading HTTP/1 + # data`) rather than the DecodeError a truncated item gives. Reproducing it + # needs the listener killed underneath the client, which leaves nothing for + # the retry to reach, so the recovery decision is asserted where it is made: + # see "watch-stream failures are recoverable" in test/helpers.jl. + + @testset "an endlessly empty watch backs off instead of spinning" begin + # A server that answers 200 and ends the stream without delivering + # anything is not a retryable failure, so k8s_retry never sees it. Left + # unthrottled the loop would re-establish as fast as the apiserver could + # answer. + url, requests, stop = fakeapi() do http, n, alive + frame(http, "") # a response, but no events, ever + end + ctx = fakectx(url) + stream = Kuber.KuberEventStream(16) + watcher = startwatch(ctx, stream) + sleep(1.0) # let the first attempts happen and compile + before = length(watchqueries(requests)) + sleep(3.0) + attempts = length(watchqueries(requests)) - before + @test attempts <= 6 # backing off, not spinning + close(stream) + @test timedwait(() -> istaskdone(watcher), 20.0) == :ok + stop() + end + + @testset "establish failures are retried, then surfaced" begin + # Nothing listening: a transport failure while establishing the watch is + # what k8s_retry actually wraps. + ctx = fakectx("http://127.0.0.1:1") + stream = Kuber.KuberEventStream(4) + wctx = Kuber.KuberWatchContext(ctx, stream) + @test_throws Exception list(wctx, :Pod; watch = true, push_initial = false, + resource_version = "1", max_tries = 1) + end +end